这两周入门了Spring框架，接下来就是学习mybatis了，所以在学习新一个框架前，对学习的框架做一个总结，以方便新手进行学习。

主要是学习了Spring的IOC控制反转、AOP、JDBC模板和Spring事物管理。那么我就总结一下这几方面的学习经验，主要是加上代码进行理解。

IOC

IOC就是把创建和查找依赖对象的控制权交给了容器，由容器进行注入组合对象。在传统中当我们用的对象时通常回去NEW一个对象，但是IOC通过配置文件把对象生成，便宜实现bean的管理和操作。
那么怎么通过配置进行bean对象的生成呢，即IOC过程，我就介绍两种方式吧，一种就是使用无参构造创建对象，另一种就是通过注解的方式生成对象。
(1)使用无参构造生成对象

   <?xml version="1.0" encoding="UTF-8"?>
     <beans xmlns="http://www.springframework.org/schema/beans"
     xmlns:mvc="http://www.springframework.org/schema/mvc"
     xmlns:p="http://www.springframework.org/schema/p"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:context="http://www.springframework.org/schema/context"
   xsi:schemaLocation="
    http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans.xsd
    http://www.springframework.org/schema/mvc
    http://www.springframework.org/schema/mvc/spring-mvc.xsd
    http://www.springframework.org/schema/context
    http://www.springframework.org/schema/context/spring-context.xsd">
    <!-- 
       说明：IOC为控制反转，把对象创建交给spring进行操作
       DI：向类的属性中设置值，在IOC上完成操作。
     -->
   <!--使用无参构造创建对象  -->
   <bean id="hell"  class="Uclass.hello"></bean>   
  </beans>

当然这只是配置类对象的方式而已还不能使用，我们还需配置另一个具有hello这个类为属性的另一个类来调用hello类对象的方法。那么就涉及到注入属性的问题了，注入属性有参构造注入属性和使用Set方法注入等，那么一般都是使用set方法注入，这里以这种方法来写。

<?xml version="1.0" encoding="UTF-8"?>
     <beans xmlns="http://www.springframework.org/schema/beans"
     xmlns:mvc="http://www.springframework.org/schema/mvc"
     xmlns:p="http://www.springframework.org/schema/p"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:context="http://www.springframework.org/schema/context"
   xsi:schemaLocation="
    http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans.xsd
    http://www.springframework.org/schema/mvc
    http://www.springframework.org/schema/mvc/spring-mvc.xsd
    http://www.springframework.org/schema/context
    http://www.springframework.org/schema/context/spring-context.xsd">

   <bean id="hello" class="Uclass.hello"> 
   </bean> 
   <!-- 使用set注入对象属性，即属性为另一个类的对象 -->
   <bean id="demo"  class="Uclass.Demo">-->
            <!-- 
               name的值都是属性名
               注入对象时不能用value属性，得用ref="要注入的对象的id"
               使用注解就可以不用在调用时使用new创建对象的操作了
               
             -->
<property name="hello" ref="hello"></property>
   </bean>  

使用demo调用hello方法输出hello world

//调用hello类的对象
  //hello类
   package Uclass;

    public class hello {
          public void sayhello(){
           System.out.println("hello world");
         }
}   




 package Uclass;

 public class Demo {
     //使用set方法注入属性
     private hello hello;
public void sethello(hello hello) {
    this.hello = hello;
}
public void output(){
    System.out.println("use demo...."+hello);
    hello.sayhello();
}

(2)使用注解进行对象生成

 <?xml version="1.0" encoding="UTF-8"?>
 <beans xmlns="http://www.springframework.org/schema/beans"
xmlns:mvc="http://www.springframework.org/schema/mvc"
xmlns:p="http://www.springframework.org/schema/p"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="
    http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans.xsd
    http://www.springframework.org/schema/mvc
    http://www.springframework.org/schema/mvc/spring-mvc.xsd
    http://www.springframework.org/schema/context
    http://www.springframework.org/schema/context/spring-context.xsd">
  //扫描指定包注解
<context:component-scan base-package="Uclass"></context:component-scan>
 </beans>

使用demo

 package Uclass;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component(value="temp")//通过注解创建对象
 public class zhushuxing {
 @Autowired //通过注解创建属性得对象，还有@resource(name="属性名")  
 private  hello hello;

public void output(){
    hello.sayhello ();
}

AOP

AOP可以这么理解，当我们需要在许多类中添加相同逻辑（或记录等其他）代码的时候，一般我们编程会在每一个类中都写上这些代码。当需要修改的时候，我们又必须找出这些类来删除这些逻辑代码。AOP可以帮我们需要这些逻辑代码指定到类中的某个方法前面执行，或者在方法后面执行，又或者我想指定在类的某一个位置去执行它，那么这就不是复用的问题了，而是要修改类了，变成动态的了。

 <?xml version="1.0" encoding="UTF-8"?>
   <beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:util="http://www.springframework.org/schema/util"
xsi:schemaLocation="
    http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans-2.0.xsd
    http://www.springframework.org/schema/aop
    http://www.springframework.org/schema/aop/spring-aop-2.0.xsd
    http://www.springframework.org/schema/util
    http://www.springframework.org/schema/util/spring-util-2.0.xsd">
    
    <!-- 创建bean对象 -->
    <bean id="aop1" class="spring.aop1"></bean>
        <bean id="aop2" class="spring.aop2"></bean>
      
    <!-- 配置aop操作 -->
       <aop:config> 
       <!-- 配置切入点，即在哪个类要做插入 
        execution(* spring.aop1.add(..))为三种表达式的一种
        id="ao1"值为随便去，但下面的pointcut-ref="ao1"的值要对应
       -->
           <aop:pointcut expression="execution(* spring.aop1.add(..))"  id="ao1"/> 
         <!-- 配置切入面，即让要入的方法在本类方法之前还是之后 -->
              <aop:aspect ref="aop2">
                 <aop:before method="delete"  pointcut-ref="ao1"/>
               </aop:aspect>
          </aop:config>     
</beans>

这里的两个类的代码没有保存，所以就不上代码了，通过配置文件即在不用修改aop2的类代码就能调用aop1的方法在aop2进行输出。

JDBC模板

相对于java原生的JDBC，使用Spring的模板对数据库进行管理会更方便

基础模板

 package jdbcTemper;

  import java.sql.ResultSet;
 import java.sql.SQLException;
 import java.util.List;

 import org.junit.Test;
 import org.springframework.jdbc.core.JdbcTemplate;
 import org.springframework.jdbc.core.RowMapper;
import org.springframework.jdbc.datasource.DriverManagerDataSource;

public class jdbc {
@Test
public void add(){
   //设置数据库信息
    DriverManagerDataSource dataSource=new DriverManagerDataSource();
    dataSource.setDriverClassName("com.mysql.jdbc.Driver");
    dataSource.setUrl("jdbc:mysql://127.0.0.1:3306/guan");
    dataSource.setUsername("root");
    dataSource.setPassword("123456");       
    //创建template模板对象，设置数据源
    JdbcTemplate jdbc=new JdbcTemplate(dataSource);
    //调用模板对象实现天加操作
    
    //String sql="insert into users value(?)";添加
    //String sql="delete from users where username=?"删除
    //String sql="update users set where username=?" 修改
    //int i=jdbc.update(sql, "spring");
    //System.out.println(i);
///////////////////////
//  查询
    //查询返回某一个值
    //String sql="select count(*) from users";
    //调用jdbc Template的方法
    //int  name=jdbc.queryForObject(sql, Integer.class);
    //System.out.println(name);
/*
 * 查询对象，第一第二步和上面的相同
 * 下面方法中第二个参数使接口rowMapper，需要自己写一个类来实现它，要new你实现接口的类，第三个参数是要查询的变量
 * */   
    //String sql="select * from users where username=?";
//  User user=jdbc.queryForObject(sql, new myrowMapper(), "spring");
//  System.out.println(user.getUsername());
/**
 * 查询发回list集合
 * 
 */
String sql ="select * from users";  
List <User> list=jdbc.query(sql, new myrowMapper());    
    System.out.println(list);
    
    
    
  }

}
  //实现查询返回对象和list集合的操作
 class myrowMapper implements RowMapper<User>{

        @Override
        //ResultSet和java中jdbc的一样，只是上部分已被封装了，到这一步自己实现查询
    public User mapRow(ResultSet rs, int arg1) throws SQLException {
    // TODO Auto-generated method stub
    String username= rs.getString("username");
     User user=new User();
     user.setUsername(username);
    
    return user;
}
 
 }

对于如何使用这个模板，在我学习的代码中已经注解了过程，看懂应该不难，还有就是使用配置文件和模板一起使用的方法了，这里就不介绍了。

Spring事务管理

Spring事物管理在我理解就是 ,事务就是对一系列的数据库操作（比如插入多条数据）进行统一的提交或回滚操作，
如果插入成功，那么一起成功，如果中间有一条出现异常，那么回滚之前的所有操作。
这样可以防止出现脏数据，防止数据库数据出现问题。 开发中为了避免这种情况一般都会进行事务管理。
在JDBC中是通过Connection对象进行事务管理的，默认是自动提交事务，可以手工将自动提交关闭，
通过commit方法进行提交，rollback方法进行回滚，如果不提交，则数据不会真正的插入到数据库中。