Spring小结

1、IOC 容器

1、概念

IOC为Inversion of control，控制反转，意思是现在需要对象，自己不创建，交给外部的容器创建
IOC容器= bean.xml配置 + ApplicationContext容器类

2、简单使用

引入jar

commons-logging-1.1.3.jar       【单独下载】
spring-beans-3.2.5.RELEASE.jar        【spring源码, bean节点管理】
spring-context-3.2.5.RELEASE.jar      【spring上下文类】
spring-core-3.2.5.RELEASE.jar         【IOC容器】
spring-expression-3.2.5.RELEASE.jar    【spring表达式】

新建applicationContext.xml
```
 
```
配置

获取

// 容器对象(加载applicationContext.xml配置文件)
ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
// 获取对象
UserAction userAction = (UserAction) ac.getBean("userAction");
userAction.execute();

3、配置细节

细节1

id 不能以数字开头，不能含有特殊符号, 不能有空格、逗号等， id 不能重复
name 可以以数字开头，可以有特殊符合，如果name值重复，编译没有问题但运行报错

细节2
```
 
  
```

4、创建对象的几种方式

构造赋值
```
  
  
```

set赋值

工厂创建对象
```
 
 

   
  
 
 
```
p名称空间
```
 
```

自动装配

注解




  // 把userDao对象加入IOC容器
  //@Component("userdao")  // 
  //@Repository("userdao")  // 

  @Repository   // 默认名称是类名，且第一个字母小写
  public class UserDao implements IUserDao {
      // 模拟：保存对象
      public void save() {
          System.out.println("UserDao.save()");
      }
  }
//@Component("userService")  // 把当前类加入IOC容器
  //@Service("userService")  // 把当前类加入IOC容器
  @Service
  public class UserService implements IUserService {
      
      //@Resource(name = "userDao")   // 根据”userDao“去ioc容器找对象，找到后注入到当前方法参数
      
      @Resource       // 默认会根据private IUserDao userDao 这里的名称去容器找； 如果没有找到，再根据类型找，再没有找到就报错！
      private IUserDao userDao;

      public void save() {
          userDao.save();
      }
  }


  //@Component("userAction")  // 加入IOC容器
  //@Controller("userAction")  // 加入IOC容器
  @Scope("prototype")       // 指定加入ioc容器的对象为多例

  @Controller
  public class UserAction {
      
  //  @Resource(name = "userService")  // ioc容器找名称是userService的对象并注入
      
      @Resource
      private IUserService userService;
      
      public String execute(){
          userService.save();
          return "success";
      }
  }

2、Spring与Struts2整合

1、关键

把action的创建，交给spring的ioc容器

2、引入jar

struts2-spring-plugin-2.3.4.1.jar 【struts源码】
spring-web-3.2.5.RELEASE.jar 【spring源码】

3、配置web.xml




    
    
        struts2
        org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter
    
    
        struts2
        /*
    

    
    
        contextConfigLocation
        /WEB-INF/classes/bean*.xml
    
    
        org.springframework.web.context.ContextLoaderListener
    


    
        index.jsp

3、Aop编程

1、概念

Aop编程：关注点代码与业务代码分离(jdk/cglib代理)
关注点：重复执行的代码, 也叫关注点代码
切面：关注点代码形成的类，就叫做切面

2、步骤

引入jar

aopalliance.jar               【spring-framework-2.5.6\lib\aopalliance】
aspectjrt.jar                【spring-framework-2.5.6\lib\aspectj】
aspectjweaver.jar             【spring-framework-2.5.6\lib\aspectj】
spring-aop-3.2.5.RELEASE.jar     【Spring3.2源码】

引入aop名称空间和开启aop注解
```
  
  
  
  
```

使用Aop相关注解

  // 重复代码
  @Component("aop")
  @Aspect      // 指定一个类为切面类
  public class TransactionAop {
      
      // 定义一个切入点表达式变量  （后面使用这个切入点表达式的时候，直接引用方法名即可）
      @Pointcut("execution(* xxxx.UserDao.*(..))")
      public void pointcut_(){
      }

      //【前置通知】
      // 在执行业务方法，之前执行
      @Before("pointcut_()")
      public void beginTransaction() {
          System.out.println("[前置通知]  开启事务..");
      }
      
      //【后置通知】
      // 在执行业务方法，之后执行
      @After("pointcut_()")
      public void commit() {
          System.out.println("[后置通知] 提交事务..");
      }
      
      // 【返回后通知】   在执行目标方法结束后执行, 出现异常不会执行
      @AfterReturning("pointcut_()")
      public void afterReturing(){
          System.out.println("[返回后通知]");
      }
      
      // 【异常通知】   在执行目标方法的时候出现异常执行
      @AfterThrowing("pointcut_()")
      public void afterThrowing(){
          System.out.println("[异常通知]");
      }
      
      // 【环绕通知】 会环绕目标方法执行
      @Around("pointcut_()")
      public void arroud(ProceedingJoinPoint pjp) throws Throwable{
          System.out.println("[环绕前：]");
          pjp.proceed();                 // 执行目标方法
          System.out.println("[环绕后：]");
      }

  }

XML配置方式

3、切入点表达式语法详解

切入点表达式：拦截指定的类，生成代理对象

表达式

 execution(
  modifiers-pattern?                  拦截的方法的访问修饰符
  ret-type-pattern                   方法返回类型，必须指定
  declaring-type-pattern?             拦截的方法所在的类
  name-pattern(param-pattern)       拦截的方法（以及方法的参数列表）
  throws-pattern?)                  方法声明的异常

4、Spring对jdbc模块的支持

1、配置

db.properties

driverClass=com.mysql.jdbc.Driver
jdbcUrl=jdbc:mysql:///hib_demo
user=root
password=root
initialPoolSize=3
maxPoolSize=6
acquireIncrement=2

applicationContext

JdbcTemplate Api

public class DeptDao implements IDeptDao {
      
      // 接收容器注入的JdbcTemplate对象
      private JdbcTemplate jdbcTemplate;
      public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
          this.jdbcTemplate = jdbcTemplate;
      }
      

      // 1. 原始jdbc代码
      public void save(Dept dept) {
          jdbcTemplate.update("insert into t_dept(deptName) values(?)", dept.getName());
      }


      @Override
      public void delete(Serializable id) {
          jdbcTemplate.update("delete from t_dept where id=?", id);
      }
      
      @Override
      public void update(Dept dept) {
          jdbcTemplate.update("update t_dept set deptName=? where id=?", dept.getName(),dept.getId());
      }


      @Override
      public Dept findById(Serializable id) {
          // queryForList 把每一行都封装为map对象，再添加到list中
  //      List> list = jdbcTemplate.queryForList("select * from t_dept");
          
          // 传入类型参数，表示查询的列的类型；  这里只能查询一列
  //      List list = jdbcTemplate.queryForList("select deptName from t_dept", String.class);

           List list = jdbcTemplate.query("select * from t_dept where id=?",  new MyRowMapper(), id);
          
          return (list!=null&&list.size()>0)?list.get(0):null;
      }


      @Override
      public List getAll() {
          List list = jdbcTemplate.query("select * from t_dept", new MyRowMapper());
          return list;
      }
      
      
      
      // 封装Springjdbc查询的结果集
      class MyRowMapper implements RowMapper{
          
          // 如何解析一行
          @Override
          public Dept mapRow(ResultSet rs, int rowNum) throws SQLException {
              Dept dept = new Dept();
              dept.setId(rs.getInt("id"));
              dept.setName(rs.getString("deptName"));
              return dept;
          }
          
      }
      
  }

5、Spring声明式事务管理

1、Jdbc（DataSourceTransactionManager）

引入jar
Spring 核心
Spring Aop 切面编程
Spring-jdbc / Spring-tx / 驱动包、连接池

XML方式

注解方式

  
  

      
      
          
          
          
          
          
          
      

      
      
          
      
      
      
      
          
      
      
      
      
      
      

      

       


@Repository    // 当期类加入ioc容器
public class DeptDao implements IDeptDao {

  // 注入JdbcTemplate对象
  @Resource
  private JdbcTemplate jdbcTemplate;

  public void save() {
      jdbcTemplate.update("insert into t_dept(deptName)values('test..')");
  }
}

@Service
public class LogService {

    @Resource
    private JdbcTemplate jdbcTemplate;

    // 事务控制
        //@Transactional，写到方法上， 表示当前方法应用事务控制
                          写到类上，  表示当前类的所有方法都会应用事务
                          写到父类上， 当执行父类的这个方法时候才应用事务
    @Transactional(propagation=Propagation.REQUIRES_NEW)
    public void insertLog() {
        jdbcTemplate.update("insert into t_log values('在插入部门....')");
    }

}

@Service
public class DeptService implements IDeptService {

  @Resource
  private IDeptDao deptDao;
  
  @Resource
  private LogService logService;
  
  // 当前方法应用事务
  @Transactional(
          readOnly=false,      // 读写的事务，当修改数据时候用；如果查询就设置为true
          isolation=Isolation.DEFAULT,  // 事务隔离级别
          timeout=-1,         // 事务执行的超时时间, -1 表示不超时
          //noRollbackFor=ArithmeticException.class,   // 遇到指定的异常不回滚
          propagation=Propagation.REQUIRED      // 事务传播行为
         //REQUIRES_NEW  当前执行方法必须在事务环境下运行，且当前执行方法始终开启一个新的事务
         //REQUIRED   当前执行方法必须在事务环境下运行,
                      如果调用当前方式时候已经有一个事务环境，当前执行方法会加入当前事务环境，就不开启新的事务,
                      如果调用当前方法时候没有事务环境，就开启一个新的事务!
         //SUPPORTS       支持事务环境！ 如果当前方法没有事务，也可以运行！
        //Never           当前方法不能再事务环境下运行！
  )
  public void save() {
      // 插入日志
      logService.insertLog();
      
      int i = 1/0;
      
      // 插入部门
      deptDao.save();
  }
}

2、 Hibernate(HibenateTransactionManager)

引入jar
hibernate jar
spring – core
spring – aop
spring – orm 对orm支持
spring-jdbc-3.2.5.RELEASE.jar
spring-orm-3.2.5.RELEASE.jar
spring-tx-3.2.5.RELEASE.jar

Spring创建SessionFactory几种方式

 
 
      
 
 
     
     
     
     
     
     
 
      
      

 
  
  
  
  
  
     
     
     
     
     
         
             org.hibernate.dialect.MySQLDialect
             true
             update
         
     
     
     
     
     
         
             classpath:xxx/entity

Spring对dao操作的支持
1、直接在dao中使用sessionFactory对象操作数据库
2、使用Spring提供的 HibernateTemplate 工具类操作数据库，优点：对session的常用操作进行封装！比较方便!
3、(推荐)HibernateDaoSupport工具类，Dao类直接继承HibernateDaoSupport工具类即可，HibernateDaoSupport对hibernateTemlate类进行了封装