spring

spring的作用及优势

Spring的作用

Spring用于整合软件开发中的各种框架，提供组件之间松耦合的平台，目的就是将耦合度降至最低，即解耦。（开源，都是相通的。所有的框架都是基于反射实现的。）

1. spring用于整合各种框架，简化开发比如DAO层，只要使用spring的一个工具类即可

2. 解耦，松耦合让类与类之间的联系不大。降低依赖性，换了一个类，不影响整个项目。项目开发过程中，难点不是模块不好开发，功能能否实现，而是怎么整合各个程序员开发的程序代码。类比较多的时候不好管理，spring是将类与类之间的关联降至最低。

3. 我们在使用Spring框架时，主要是使用Spring容器的两个特性：IoC和AOP。

spring的优势

1. spring是一个开源框架，开放源代码

2. spring 为JavaEE应用提供轻量级的解决方案；

3. spring提倡”最少侵入”；（降低耦合度，换了谁都可以）

4. spring是一个优秀的MVC框架

5. 基于依赖注入的核心机制,基于AOP的声明式事务管理

spring容器

概念

spring框架的核心就是提供了一个容器。该容器类型是BeanFactory或者ApplicationContext（建议用这个类型，它是BeanFactory的子类，功能更多）

Spring的核心接口：BeanFactory

该容器具有以下功能：

a. 容器可以创建和销毁组件对象，等价于原来”工厂”类的作用。

b. 容器可以采用不同的模式创建对象，如单例模式创建对象

c. 容器具有IOC机制实现

d. 容器具有AOP机制实现

容器实例化

BeanFactory创建并负责管理Spring bean的上下文的生命周期。BeanFactory接口指明了spring到底干了什么事。

org.springframework.beans.factory.xml.XmlBeanFactory 是BeanFactory的实现类，在XMLBeanFactory中，以xml结构方式描述对象及对象之间的依赖关系。

创建BeanFactory实例时，必须提供Spring容器管理bean的详细配置信息，相应的XML文件作为参数传入。

BeanFactory factory = new ClassPathXmlApplicationContext(“applicationContext.xml”);

BeanFactory factory = new FileSystemXmlApplicationContext(“F:/applicationContext.xml”);

推荐使用ClassPathXmlApplicationContext方式

Bean对象

Bean指代的就是对象，BeanFactory是产生和管理bean的容器。

a. 产生bean

b. 控制Bean的产生数量

c. 控制Bean的产生时间

d. 控制Bean的生命周期

Spring通过BeanFactory管理和配置bean ,在Spring里，任何的java对象、java组件bean处理。

spring环境的搭建

1. 创建web工程

2. 导入jar　　spring.jar commons-logging.jar log4j-1.2.15.jar

3. 导入配置文件　　log4j.properties applicationContext.xml

实例化Bean对象方式

a. 用构造器来实例化

<bean  id=”XXBean”  class=”” />

b. 使用静态工厂方法实例化

<bean  id=”XXbean”  class=”XXXfactoryClass”  factory-method=”” />

c. 使用实例工厂方法实例化

<bean  id=”XXfactory”  class=”” />
<bean  id=”XXXbean”  factory-bean=”XXX”  factory-method=”” />

将一个Bean组件交给Spring容器管理，获取spring容器对象和Bean对象

案例

1. 新建web功能

2. 导入jar包

3. 创建Bean1对象

public class Bean1{}

4. 工厂类

public class Bean1Factory {
　　public Bean1Factory(){
   　　System.out.println("创建工厂对象");
　　}
　　//使用静态方法获得对象
   public static Bean1 getBean1(){
  　　 return new Bean1();
　　}
　　//使用实例方法获得对象
　　public Bean1 getBean(){
　　　　return new Bean1();
　　}
}

5. 添加配置文件applicationContext.xml文件

<?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:mvc="http://www.springframework.org/schema/mvc"
    xmlns:aop="http://www.springframework.org/schema/aop" 
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
    http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.2.xsd
    http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.2.xsd 
    http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.2.xsd ">
 
    <!-- 把bean1配置到是pring,让spring管理bean1
         id:该bean的标识，用来区分开每一个bean（类的对象）
         class:指明配置的具体的类，包名+类名,底层利用反射创建对象class.forName()-->
    <bean id="bean1" class="web.test.bean.Bean"></bean>
    <!-- 在spring中调用工厂的静态方法创建对象 -->
    <bean id="bean2" class="web.test.factory.Bean1Factory"    factory-method="getBean1"></bean>
    <!-- 在spring中，调用工厂的实例方法，获得对象 -->
    <!-- 1、先把工厂实例化 -->
    <bean id="factory" class="web.tarena.factory.Bean1Factory"></bean>
    <!-- 2、调用工厂中的实例方法获得对象 -->
    <bean id="bean3" factory-bean="factory"    factory-method="getBean1"></bean>
</beans>

5. 测试类

public class TestSping {
    public void test1() {
        /**
         * ClassPathXmlApplicationContext：用来加载核心配置文件。applicationContext.xml，比较消耗资源,重量级对象，所以应该写成静态的，只加载一次。
         * 重量级对象：功能强大，消耗资源较多，ClassPathXmlApplicationContext和HibernateSessionFactory都是重量级对象
         * BeanFactory接口 Object getBean(String name); name就是指配置文件中的id值 返回结果是Object，spring可以管理任意的对象
         */
        ApplicationContext beanFactory = new ClassPathXmlApplicationContext("applicationContext.xml");
        // 通过构造器创建Bean对象
        Bean bean1 = (Bean)beanFactory.getBean("bean1");
        System.out.println(bean1);
        // 通过工厂的静态方法创建Bean对象
        Bean bean2 = (Bean)beanFactory.getBean("bean2");
        System.out.println(bean2);
        // 通过实例化工厂方法创建Bean对象
        Bean bean3 = (Bean)beanFactory.getBean("bean3");
        System.out.println(bean3);
    }

    public void test2() {
        // 单例模式下不同的beanFactory创建出来的Bean对象不是同一个
        BeanFactory beanFactory = new ClassPathXmlApplicationContext("applicationContext.xml");
        System.out.println("---------------------------");
        Bean bean1 = (Bean)beanFactory.getBean("bean1");
        System.out.println(bean1);
        BeanFactory factory = new ClassPathXmlApplicationContext("applicationContext.xml");
        Bean bean11 = (Bean)factory.getBean("bean1");
        System.out.println(bean11);

    }
}

spring容器对Bean组件的管理

Bean对象的创建模式

Spring支持singleton（单例）和prototype（原型，非单例）两种模式。Singleton：每次调用getBean()返回同一个对象。prototype：每次调用getBean()返回新的对象。

默认是singleton模式，可以通过<bean>的scope属性修改为prototype模式。例如：<bean id=”标识符” scope=”prototype” class=”Bean组件类型” />

Bean对象的创建时机

a. singleton模式的Bean组件是在容器实例化时创建的。

b. prototype模式是在调用getBean()方法时创建。

c. singleton模式可以使用<bean>元素的lazy-init=”true”属性将对象的创建时机推迟到调用getBean()方法。也可以在<beans>(根元素)中使用default-lazy-init=”true”推迟所有单例Bean组件的创建时机。

Bean对象的初始化和销毁

初始化

1. 可以利用<bean>元素的init-method=”方法名”属性指定初始化方法。

2. 指定的初始化方法是在构造方法调用后自动执行。若非单例模式，则每创建一个对象，则执行一次初始化方法。

初始化的三种方式

1. 写在构造方法中

2. 写在{}中(代码块)；

2. spring框架中<bean>元素写init-method=”方法名”

初始化不能用static{},它是类加载调用，比创建对象要早。

销毁

1. 可以利用<bean>元素的idestory-method=”方法名”属性执行销毁方法。

2. 销毁方法是在容器关闭时触发，而且只适用于singleton模式的组件

//spring容器关闭
AbstractApplicationContext  ac=new ClassPathXmlApplicationContext();
ac.getBean(“feeDAO”);
ac.close();//该方法执行后，Bean对象被销毁

spring框架的IOC特性

IOC概念

IOC，Inverse of Controller被称为控制反转或反向控制，其实真正体现的是”控制转移”。所谓的控制指的是负责对象关系的指定、对象创建、初始化、和销毁等逻辑。

IOC指的是将控制逻辑交给第三方框架或容器负责（即把Action中的控制逻辑提出来，交给第三方负责），当两个组件发生改变时，只需要修改框架或容器的配置即可。

控制反转就是应用本身(Action)不负责依赖对象(Dao)的创建及维护，依赖对象的创建及维护是由外部容器(BeanFactory)负责的。这样控制权就由应用转移到了外部容器，控制权的转移就是所谓反转。

DI概念

DI，Dependency Injection依赖注入

依赖注入就是指：在运行期，由外部容器(BeanFactory)动态地将依赖对象(Dao)注入到组件(Action)中。Spring框架采用DI技术实现了IoC控制思想。

Spring提供了两种形式的注入方式：

①（常用）setter方式注入：依靠set方法，将组件对象传入（可注入多个对象）

a. 首先添加属性变量和set方法

b. 在该组件的<bean>定义中采用下面的描述方式 <property name=”属性名” ref=”要注入的Bean对象的id值”></property>

c. 属性名与set方法名对应，和属性名无关。例如CostAction中有costDao属性，而他的标准set方法名为setCostDAO，那么配置文件中的name就应该写costDAO(去掉set,首字母小写)。name不是看定义的属性名，而是set方法名。

②（用的少）构造方法注入：依靠构造方法，将组件对象传入

a. 在需要注入的组件中，添加带参数的构造方法。

b. 在该组件<bean>定义中，使用下面格式描述<constructor-arg index=”参数索引” ref=”要注入的Bean对象的id值” />

DI和IOC的关系

Spring是具有IoC特性的框架，实现Ioc是由Spring容器完成的，Spring容器通过DI建立起对象之间的关系。可以这样理解：DI是IoC实现的一种手段，IoC的理论通过DI实现。

案例

UserDao

public interface UserDAO {
    public void saveUser(String user);
}

UserDAOOracleImpl

public class UserDAOOracleImpl implements UserDAO{
    public void saveUser(String user) {
        System.out.println("oracle实现");
    }
}

UserDAOMysqlImpl

public class UserDAOMysqlImpl implements UserDAO{
    public void saveUser(String user) {
        System.out.println("mysql实现");
    }    
}

UserAction

public class UserAction {
    private UserDAO userDao;
    //Action依赖DAO,保存数据。把依赖的UserDao写到方法的外面,可以通过set方法注入不同实现的dao对象
    //这样操作不同的数据库的时候，不用对UserAction进行任何的修改或者完全通过配置文件进行配置
    public void saveUser(String username){
        userDao.saveUser();
    }
    //set方式注入
    //public void setUserDao(UserDAO userDao) {
    //     this.userDao = userDao1;
    //}
     //构造方式注入
    public UserAction(UserDAO userDao) {
        this.userDao=userDao;
    }
}

applicationContext.xml

<beans ...>
    <!-- 把所有的Dao和Action全部配置到spring当中，全部纳入spring的管理 -->
    <bean id="userDaoMySql" class="com.test.dao.impl.UserDaoMySqlImpl"></bean>
    <bean id="userDaoOracle" class="com.test.dao.impl.UserDaoOracleImpl" ></bean>
    <bean id="userAction”  class="com.tarena.web.action.UserAction" >
    　　<!-- set方式注入 -->
    　　<!--<property name="userDao1" ref="userDaoOracle"></property>-->
    　　<!-- 构造器方式注入 -->
    　　<constructor-arg ref="userDaoDB2"></constructor-arg>
　　</bean>
</beans>

各种数据类型的注入

Bean3

//使用spring创建对象的时候，创建的同时给对象属性赋值
public class Bean3 {
    private int id;
    private String name;
    private String[] arrayValue;
    private List listValue;
    private Set  setValue;
    private Map mapValue;
    private Properties propValue;
    //get set方法
}

appliactionContext.xml

<beans  ..>
    <bean id="bean3" class="web.tarena.bean.Bean3">
    <!-- set方式注入 -->
    <property name="id" value="12"></property>
    <property name="name" value="liu"></property>
    <property name="arrayValue">
        <list>
            <value>a</value>
            <value>b</value>
            <value>c</value>
        </list>
    </property>
    <property name="listValue">
　　　　<!-- list和数组很相似 -->
　　　　<list>
　　　　　　<value>list1</value>
　　　　　　<value>list2</value>
　　　　　　<value>list3</value>
　　　　</list>
　　</property>
　　<property name="setValue">
　　　　<set>
　　　　　　<value>set1</value>
　　　　　　<value>set2</value>
　　　　</set>
　　</property>
　　<property name="mapValue">
　　　　<map>
　　　　　　<entry key="k1" value="v1"></entry>
　　　　　　<entry key="k2" value="v2"></entry>
　　　　</map>
　　</property>
　　<property name="propValue">
　　　　<props>
　　　　　　<prop key="p1">v1</prop>
　　　　　　<prop key="p2">p2</prop>
　　　　</props>
　　</property>
</bean>
</beans>

AOP概念

什么是AOP

AOP，Aspect Oriented Programming被称为面向方面编程。对单个对象（一对一）的解耦用IoC，而当有共通组件，它对应多个其他组件（一对多），则解耦用AOP。如拦截器。这也是为何在程序中大量的用IoC,而AOP却用的很少，因为程序中不可能有很多的共通部分。

AOP主要解决共通处理和目标组件之间解耦。

AOP的相关术语

1. 方面Aspect，指的是封装了共通处理的功能组件。该组件可以作用到某一批目标组件的方法上。方面也可以说是通知的集合。

2. 通知Advice，用于指定方面组件的目标组件方法之间的作用时机。例如：先执行方面组件再执行目标方法，或先执行目标方法再执行方面组件。

3. 目标对象Target，要使用Advice操作的方法的对象

4. 连接点JoinPoint，指的是方面组件和具体的哪一个目标组件的方法有关系。

5. 切入点Pointcut，用于指定目标组件的表达式。指的是方面组件和哪一批目标组件方法有关系。多个连接点组成的集合就是切入点。

AutoProxy动态代理

采用AOP之后，容器返回的对象是代理对象。用户在使用时，由代理对象调用切面组件和目标对象的功能。

spring支持JDK动态代理和cglib动态代理。JDK动态代理默认提供的，spring以JDK代理为主。cglib动态代理，spring需要依赖第3方cglib-nodep-2.1_3.jar来实现。

注意spring在默认情况下

1. 目标对象有接口采用JDK动态代理。比如 FeeDaoImpl implements FeeDAO

2. 目标对象没有接口采用CGLIB代理。

修改配置<aop:config proxy-target-class="true"/>　proxy-target-class默认是false，表示有接口使用JDK，没有接口使用cglib代理。设置成true，强制都使用cglib代理

AOP案例

想让所有的操作进行日志记录，那么按以前的方式就需要给所有Action或DAO中添加日志记录的代码，如果Action或者DAO很多，那么不容易维护。而使用AOP机制，则可以很方便的实现上述功能。

1. 导入AOP需要的包 aspectjrt.jar aspectjweaver.jar

2. 目标对象

3. 切面类

//切面类(Aspect)
public class LoggerBean {
     //这个类下面的方法都是通知。通知(Advice),切面类中的方法就是通知
    public void logger(){
        System.out.println("记录当前的操作");
    }
}

4. 配置文件

<beans ...>
    <!-- 切面类 -->
    <bean id="loggerBean" class="com.test.aop.aspect.LoggerBean"></bean>
    <!-- 目标对象 -->
    <bean id="feeDao" class="com.test.dao.impl.feeDaoImpl"></bean>
    <!-- 配置AOP -->
    <aop:config>
    　　<!-- 切入点,如何找连接点，pointcut就是一个表达式,用来指向连接点(要操作的方法)，within(com.test.dao.impl.*)在这个包下面的所有类和所有方法 -->
       <aop:pointcut expression="within(com.tarena.dao.impl.*)" id="feeDaoPoint"/>
       <!-- 切面,id切面的标识, -->
       <aop:aspect id="loggerAspect" ref="loggerBean">
              <!-- 通知前,就是在调用连接点之前调用方法logger,切入点feeDaoPoint所对应的路径com.test.dao.impl.*,即impl包下所有的方法在执行前都用logger方法 -->
              <aop:before method="logger" pointcut-ref="feeDaoPoint"/>
       </aop:aspect>
　　 </aop:config>
</beans>

通知类型和切入点

通知类型

通知决定方面组件和目标组件作用的关系。主要有以下几种类型通知

a. 前置通知 <aop:before/>，方面组件在目标方法之前执行

b. 后置通知<aop:after-returning/>，方面组件在目标方法之后执行，目标方法没有抛出异常才执行方面组件

c. 最终通知<aop:after>，方面组件在目标方法之后执行，目标方法有没有异常都会执行方面组件。

d. 异常通知<aop:after-throwing>，方面组件在目标方法抛出异常后执行。

e. 环绕通知<aop:around>，方面组件在目标方法之前和之后执行。环绕通知等价于前置+后置通知

try{
    //前置通知
    //执行目标方法
    //后置通知
} catch(){
    //异常通知
}fially{
    //最终通知
}

切入点

切入点用于指定目标组件和方法，Spring提供了多种表达式写法

方法限定表达式

指定哪些方法启用了方面组件

①execution(修饰符? 返回类型方法名(参数列表) throws 异常?)

②示例

execution(public * *(..))：匹配容器中所有修饰符是public(不写则无要求的)，返回类型、方法名，参数列表也不要求的方法。

execution(* set*(..))：匹配容器中，方法以set开头的所有方法

execution(* org.test.CostDAO.*(..))：匹配CostDAO类中的所有方法。

execution(* org.test.dao.*.*(..))：匹配dao包下所有类所有方法

execution(* org.test.dao..*.*(..))：匹配dao包及子包中所有类所有方法

execution(* com.test.dao.impl.feeDaoImpl.save*(..))

第一个*指的是返回值任意

第二个*指的是方法名以save开头的任意方法

第三个..指的是方法的参数任意

类型限定表达式

指定哪些类型的组件的所有方法启用方面组件(默认就是所有方法都启用，且只到类型，不到方法)

①形式：within(类型)

②示例

within(com.xyz.service.*)，匹配service包下的所有类所有方法

within(com.xyz.service..*)，匹配service包及其子包中的所有类所有方法

within(org.test.dao.CostDAO)，匹配CostDAO所有方法

注意：within(com.xyz.service.*.*)是错误的，只到类名，不到方法名

Bean名称限定

按<bean>元素的id值进行匹配。

①形式：Bean(id值)

②示例

bean(costDAO)，匹配id=costDAO的bean对象

bean(*DAO)，匹配所有id值以DAO结尾的bean对象

args参数限定表达式

按方法参数类型限定匹配

①形式：args(类型)

②示例

args(java.io.Serializable)匹配方法只有一个参数，并且类型符合Serializable的方法。public void f1(String s)、public void f2(int i)都能匹配。

上述表达式可以使用&&、||运算符连接使用

案例A-环绕通知

环绕通知与其他通知有点区别，它要求程序员调用目标对象的连接点方法，否则连接点方法不会执行

案例：通过logger方法显示当前用户操作的目标对象的类型以及目标对象操作的方法 (连接点的方法)

1. 导入包 aspectjrt.jar aspectjweaver.jar cglib.jar

2. 目标对象

public interface UserDao {
　　void saveUser(String username);
}

public class UserDaoImpl implements UserDao{
    //连接点
    public void saveUser(String username) {
        System.out.println("保存操作");
    }
}

3. 切面

public class LoggerBean {
　　//利用反射
   //连接点对象ProceedingJoinPoint
　　public void logger(ProceedingJoinPoint pjp) throws Throwable{
　　　　//调用目标对象的连接点方法，如果不加这句那么连接点方法不执行
　　　　pjp.proceed();
　　　　//获得当前执行的方法的类型名
　　　　String className=pjp.getTarget().getClass().getName();
  　　 //获得当前执行的方法的名字
　　　　String methodName=pjp.getSignature().getName();
　　　　System.out.println("您正在执行"+className+"类的"+methodName+"方");
　　}
}

4. 配置

<beans ...>
    <!-- 切面 -->
    <bean id="loggerBean" class="com.tarena.aop.aspect.LoggerBean"></bean>
    <!-- 目标对象 -->
    <bean id="userDao" class="com.tarena.dao.impl.UserDaoImpl"></bean>
    <!-- 配置AOP -->
    <aop:config>
        <aop:pointcut id="userDaoPointcut"  expression="execution(* com.test.dao..*.*(..))"/>
        <aop:aspect id="loggerAspect" ref="loggerBean">
            <aop:around method="logger" pointcut-ref="userDaoPointcut"/>
        </aop:aspect>
    </aop:config>
</beans>

案例B-异常通知

目标对象运行产生异常时，把异常信息通过日志方式记录到文件中。在A案例中添加

1. log4j.properties

#--------console-----------

#log4j.rootLogger=warn,myconsole
#log4j.appender.myconsole=org.apache.log4j.ConsoleAppender
#log4j.appender.myconsole.layout=org.apache.log4j.SimpleLayout

#--------file-----------

log4j.rootLogger=error,myfile
log4j.appender.myfile=org.apache.log4j.FileAppender
log4j.appender.myfile.File=D:\error.htm
log4j.appender.myfile.layout=org.apache.log4j.HTMLLayout

2. 添加切面类

//切面,(截获异常信息)
public class ExceptionLogger {
    private Log log=LogFactory.getLog(this.getClass());
    //将异常的信息写到文件中，D盘下面的error.html
    public void exceptionLogger(Exception ex){
    　　//1、获得当前异常的堆栈信息
   　　 StackTraceElement[] els=ex.getStackTrace();
    　　//2、需要放入第一行的内容els[0] (java.lang.NullPointerException)
       log.error(ex.getClass().getName());
       log.error(els[0]);
    }
}

3. 配置信息

<beans ...>
    <!-- 切面 -->
    <bean id="loggerBean" class="com.tarena.aop.aspect.LoggerBean"></bean>
    <bean id="exceptionLogger" class="com.tarena.aop.aspect.ExceptionLogger"></bean>
    <!-- 目标对象 -->
    <bean id="userDao" class="com.tarena.dao.impl.UserDaoImpl"></bean>
    <!-- 配置AOP -->
    <aop:config>
        <aop:pointcut id="userDaoPointcut" expression="execution(* com.test.dao..*.*(..))"/>
        <aop:aspect id="loggerAspect" ref="loggerBean">
            <aop:around method="logger" pointcut-ref="userDaoPointcut"/>
       </aop:aspect>
       <aop:aspect id="exceptionLoggerAspect" ref="exceptionLogger">
       　　<!-- throwing:和方法exceptionLogger中的参数名相同。注意一定要把异常抛出来才行，try-catch了不行 -->
       　　<aop:after-throwing method="exceptionLogger" pointcut-ref="userDaoPointcut" throwing="ex"/>
       </aop:aspect>
　　</aop:config>
</beans>

spring注解配置

注解技术从JDK5.0推出，之后很多框架开始提供注解配置形式。Spring框架从2.5版本开始支持注解配置。

功能：简化spring的配置文件，把spring的配置文件的信息，放入到各个类当中。

优点：方便快捷，可以减少spring的配置文件

缺点：当项目过大的时候，里面可能会有很多个类（比如1000个），在每个类当中加入注解。容易出现错误，而且不易于管理和维护。

开始是否使用注解，主要看公司的要求以及项目的规模。

AOP注解（了解）

@Aspect

@Before

@After

@Around

@AfterReturning

@AfterThrowing

@Pointcut

案例-使用注解方式

1. 在配置文件中加入：xmlns:context="http://www.springframework.org/schema/context"，content可以直接管理注解

2. applicationContext.xml文件；

<beans ...xmlns:context="http://www.springframework.org/schema/context" >
    <!-- 开启AOP注解 ,启动注解-->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
    <!-- 切面 -->
    <bean id="exceptionBean" class="com.tarena.aop.aspect.ExecptionLogger"></bean>
    <bean id="loggerBean" class="com.tarena.aop.aspect.LoggerBean"></bean>
    <!-- 目标对象 -->
    <bean id="userDao" class="com.tarena.dao.impl.UserDaoImpl"></bean>
　　 <!-- 使用注解后，就没有AOP的配置了 --></beans>

3. 切面（修改最多的）

// 使用AOP注解，首先确定切面，然后确定通知
@Aspect
public class LoggerBean {

    // 只有一个pointcut
    @Around("execution (* com.tarena.dao..*.*(..))")
    public void logger(ProceedingJoinPoint pjp) throws Throwable {
        pjp.proceed();
        String className = pjp.getTarget().getClass().getName();
        String methodName = pjp.getSignature().getName();
        String key = className + "." + methodName;
        String value = PropertiesUtil.getValue(key);
        System.out.println("用户的操作信息是：" + value);
        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
        System.out.println("操作的时间是：" + dateFormat.format(new Date()));
    }
}

@Aspect
public class ExecptionLogger {
    @Pointcut("execution (* com.tarena.dao..*.*(..))")
    // 定义一个方法，该方法只起到标记一个id的作用
    public void myPointCutId() {
    }

    // 要放两部分信息,pointcut，throwing。pointcut里面不要直接放表达式
    @AfterThrowing(pointcut = "myPointCutId()", throwing = "ex")
    public void exceptionLogger(Exception ex) {
        StackTraceElement[] els = ex.getStackTrace();
        System.out.println(els[0]);
        Logger logger = Logger.getLogger(this.getClass());
        logger.error(ex.getClass().getName());
        logger.error(els[0]);
    }
}

4. 目标对象（没有变化）

public class UserDaoImpl implements UserDao {
    // 连接点
    public void deleteUserById(int id) {
        System.out.println("删除操作");
    }
    public String findUserById(int id) {
        System.out.println("查询操作");
        return null;
    }
    public void saveUser(String uname) {
        System.out.println("保存操作");
        String str = null;
        str.charAt(1);// 抛出异常
    }
    public void updateUser(String user) {
        System.out.println("修改操作");
    }
}

web开发中的注解（组件）

applicationContext.xml文件中有<bean>元素的配置，来生成Bean对象。web开发中的注解用来取消这些配置。简化操作。

（1）组件扫描功能

spring可以按照指定的包路径扫描内部的组件，当发现组件类定义前有相应的注解

标记，会将该组件纳入spring容器管理中。

web分为三层，dao是持久层或者是模型层，action或者servlet是控制层。

@Repository:专门指代Dao层（dao层属于持久层或者模型层）

@Service:专门指代Service层

@Controller：专门用来指代控制层（action/servlet）

@Component：指代任意的一层，切记在web三层中少用，为影响对架构控制。

用多了，哪一方是dao,哪一方是service都分不清楚。

@Resource

@Autowired

注意：上述4个注解任意使用也可以，但不符合规范。

注解只能用在类定义前、方法定义前、成员变量定义前。

一般面试问的注解都是web开发中的注解，不是指AOP注解。

3、案例，使用组件注解方式

1）applicationContext.xml

<aop:aspectj-autoproxy></aop:aspectj-autoproxy>

<context:component-scan

base-package="com.tarena"></context:component-scan>

</beans>

2）切面

@Component

@Aspect

public class ExecptionLogger {

@Pointcut("execution (* com.tarena.dao..*.*(..))")

//定义一个方法，该方法只起到标记一个id的作用

public void myPointCutId(){}

//要放两部分信息,pointcut，throwing。pointcut里面不要放表达式

@AfterThrowing(pointcut="myPointCutId()",throwing="ex")

public void exceptionLogger(Exception ex){

.....

}

@Component

@Aspect

public class LoggerBean {

@Around("execution (* com.tarena.dao..*.*(..))")

public void logger(ProceedingJoinPoint pjp) throws Throwable{

.....

}

3）目标对象

@Repository("userDao")//userDao就是Bean对象的id标识

public class UserDaoImpl implements UserDao {

public void deleteUserById(int id) {

System.out.println("删除操作");

}

....

}

4）测试

public class TestSpring{

public void test1(){

BeanFactory factory=

new ClassPathXmlApplicationContext("applicationContext.xml");

UserDao dao=(UserDao) factory.getBean("userDao");

dao.findUserById(1);//测试LoggerBean切面

dao.saveUser("");//测试ExceptionLogger切面

}

4、web分层，控制层 业务层 DAO层

1）dao层

public interface UserDao {

void saveUser(String uname);

...

}

public class UserDaoImpl implements UserDao {

public void saveUser(String uname) {

System.out.println("dao保存操作");

}

public void updateUser(String user) {

System.out.println("修改操作");

}

2）业务层

根据业务需要1次或者多次的调用Dao层，业务层具体解决问题层。

业务层依赖于dao层对数据库操作，实现业务需要。

public interface UserService {

void saveUser(String uname);

}

public class UserServiceImpl implements UserService{

//调用dao

private UserDao userDao;//省略get set 方法

public void saveUser(String uname) {

System.out.println("业务：保存");

userDao.saveUser(uname);

}

3）action层

省略

4）applicationContext.xml

</bean>

</beans>

5）测试

public void test1(){

BeanFactory factory=

new ClassPathXmlApplicationContext("applicationContext.xml");

UserService service=(UserService) factory.getBean("userService");

service.saveUser("");

}

5、使用注解来维护依赖关系（注入注解）

要求给UserServiceImple注入UserDao属性。

Spring不但支持自己定义的@Autowired注解，还支持由JSR-250规范定义的几个注解，

如：@Resource、 @PostConstruct及@PreDestroy。

@PostConstruct //等价于设置了init-method=”方法名”属性

public void myinit(){...}

@PreDestroy //等价于设置了destroy-method=”方法名”属性

public void mydestroy{...}

@Resource

private UserDao userDao;

userDao是名字，UserDao是类型

1）@Resource

@Resource是J2EE提供的，需导入Package:javax.annotation.Resource;

javaee1.5不需要额外导入包，javaee1.4需要导入包common-annotations.jar

@Resource有两个中重要的属性：name和type 。

Spring将@Resource注解的name属性解析为bean的名字，而type属性则解析为

bean的类型。所以如果使用name属性，则使用byName的自动注入策略，而使

用type属性时则使用 byType自动注入策略。如果既不指定name也不指定type

属性，这时将通过反射机制使用byName自动注入策略，byName匹配不到后再使

用byType自动注入策略。

@Resource装配顺序

　 (1). 如果同时指定了name和type，则从Spring上下文中找到唯一匹配的bean进

行装配，找不到则抛出异常;

　 (2). 如果指定了name，则从上下文中查找名称（id）匹配的bean进行装配，找不

到则抛出异常;

(3). 如果指定了type，则从上下文中找到类型匹配的唯一bean进行装配，找不到

或者找到多个，都会抛出异常;

　 (4). 如果既没有指定name，又没有指定type，则自动按照byName方式进行装配；

如果没有匹配，则回退为一个原始类型进行匹配，如果匹配则自动装配；

不需要set方法

//凡是出現注解的地方都不需要set方法

2）@Autowired

@Autowired：跟@Resource功能很相似，都是用来维护依赖的关系。

@Autowired是spring提供的，默认只根据类型匹配注入。如果匹配到多个将报异常。

可以手动的按照名称匹配。

@Autowired

@Qualifier("userDao")

private UserDao userDao;

3）@Resource和@Autowired的区别

a、@Autowired 与@Resource都可以用来装配bean. 都可以写在字段上,或写在

setter方法上;写在字段上可以不用写set方法

b、@Autowired 默认按类型装配。

如果我们想使用名称装配可以结合 @Qualifier注解进行使用;

c、@Resource（这个注解属于J2EE的），默认安装名称进行装配，名称可以通过

name属性进行指定，如果没有指定name属性，当注解写在字段上时，默认取

字段名进行安装名称查找，如果注解写在setter方法上默认取属性名进行装配。

当找不到与名称匹配的bean时才按照类型进行装配。但是需要注意的是，如

果name属性一旦指定，就只会按照名称进行装配。

d、推荐使用@Resource注解在字段上，是属于J2EE的，减少了与Spring的耦

合,这样代码看起就比较优雅。

@Resource性能好，如果是@Autowired,会把UserDao接口对应的实现类全部

遍历一遍

企业开发一般都使用@Resource

4）案例

DAO层

接口

public interface UserDao {

void saveUser(String uname);

}

两个实现类

@Repository("userDao")//userDao就是Bean对象的id标识

@Scope("prototype")//单例还是多例

public class UserDaoImpl implements UserDao {

public void saveUser(String uname) {

System.out.println("保存操作");

}

@Repository

public class UserDaoMysqlImpl implements UserDao{

public void saveUser(String uname) {

...

}

业务层

接口

public interface UserService {

void saveUser(String uname);

}

实现类

@Service("userService")//userService就相当于<bean>元素中id标识的作用

public class UserServiceImpl implements UserService{

@Resource

private UserDao userDao;

public void saveUser(String uname) {

System.out.println("业务：保存");

userDao.saveUser(uname);

}

配置文件

<aop:aspectj-autoproxy></aop:aspectj-autoproxy>

<context:component-scan base-package="com.tarena"></context:component-scan>

</beans>

测试类

public void test1(){

BeanFactory factory=

new ClassPathXmlApplicationContext("applicationContext.xml");

UserService service=(UserService) factory.getBean("userService");

service.saveUser("");

}

八、数据连接池

1、为什么要使用数据连接池？

获得数据库连接的过程DriverManager.getConnection()是非常消耗系统性能的操作，如

果过于频繁获得连接，会导致系统性能急剧下降，甚至崩溃。

一般获得连接会占用85%的时间。一般上线的项目都使用连接池。

2、连接池原理

连接池中有很多创建好的连接。请求过来后，申请连接，连接池返回一个连接，用完连

接以后，释放连接（不是关闭连接），别人可以继续使用这个连接。

连接池主要做三件事：建立连接（服务器启动，建立一定数量的连接）

管理连接

释放连接（服务器关闭，连接池也关闭，连接释放）

连接池原理：复用已经建立好的数据库连接

hibernate内部默认有一个小连接池。

3、连接池的使用步骤

1）建立数据库连接池对象（服务器启动的时候创建）

2）按照事先设计好的初始化连接数量，创建数据库的连接

3）对于一个数据库的访问，直接从连接池获取连接

4）操作数据库

5）将连接重新放入连接池中

（3---5，在项目运行中反复的出现）

6）释放连接池对象

（服务器关闭，维护期间，释放数据库连接池，释放所有的连接）

4、DBCP连接池

使用必须要导入两个jar包

commons-dbcp-1.2.2.jar

commons-pool.jar

5、连接池的核心类和核心接口

1）DataSource接口 javax.sql.DataSource

DataSource 对象所表示的物理数据源的连接。作为 DriverManager 工具的替代项，

DataSource 对象是获取连接的首选方法。

DataSource有抽象方法getConnection();由实现类覆盖。

所有连接池的核心都会间接或直接实现该接口。

2）BasicDataSource类

org.apache.commons.dbcp.BasicDataSource，实现了DataSource接口

九、spring整合JDBC

1、工具类JdbcTemplate

spring整合Jdbc所用的工具类，里面封装了所有对jdbc的基本操作。

企业开发中，一般dao操作数据库都是一条sql语句+工具类的一个方法

Dao层：

String sql = “”

jdbcTemplate.方法（sql，参数）

2、创建JdbcTemplate对象

class JdbcTemplate {

带DataSource参数的构造方法来生成对应的JdbcTemplate对象。

public JdbcTemplate(DataSource dataSource) {

setDataSource(dataSource);

afterPropertiesSet();

}

所以创建JdbcTemplate对象对象需要传入一个DataSource参数

3、dao层

public class CostDaoImpl implements CostDao {

private JdbcTemplate jdbcTemplate ;

public void setDataSource(DataSource dataSource){

jdbcTemplate = new JdbcTemplate(dataSource);

}

必须注入一个DataSource对象，强调是实现DataSource接口的对象，一般注入的是连

接池核心类对象，比如BasicDataSource。

4、JdbcTemplate的常用方法

update() 增删改

query() 查询

queryForObject()

queryForList()

queryForLong()

queryForMap()

注意：查询对象的操作

jdbc返回的结果封装到ResultSet对象当中，Dao返回的结果，往往是一个entity对象。

需要从ResultSet集合转换成entity对象。需要实现spring提供的RowMapper接口。

或者使用spring的BeanPropertyRowMapper类。

public class CostMapper implements RowMapper{

//把rs转化成一个Object对象,不会有任何的问题

public Object mapRow(ResultSet rs, int rowNum) throws SQLException {

Cost cost=new Cost();

cost.setId(rs.getInt("ID"));

cost.setName(rs.getString("NAME")); .....

return cost;

}

public Cost findById(int id) {

String sql = "select * from cost" + " where id=?";

CostMapper costMapper = new CostMapper();

// return (Cost) jdbcTemplate.queryForObject(sql, new Object[]{id},costMapper );

return (Cost) jdbcTemplate.queryForObject(sql, new Object[] { id },

new BeanPropertyRowMapper(Cost.class));

//BeanPropertyRowMapper:实现RowMapper接口的对象

//不稳定，如果对象的字段为空的时候，容易出现异常

// 不同的spring版本，返回不同的结果

}

5、案例

1）实体类以及实体类对应的Mapper类

public class Cost {

private Integer id;

private String name;

private Integer baseDuration;

private Double baseCost;

private Double unitCost;

private String status;

private String descr;

private Date createTime;

private Date startTime;

private String costType;

....

}

public class CostMapper implements RowMapper{

//把rs转化成一个Object对象,不会有任何的问题

public Object mapRow(ResultSet rs, int rowNum) throws SQLException {

Cost cost=new Cost();

cost.setId(rs.getInt("ID"));

cost.setName(rs.getString("NAME"));

cost.setBaseDuration(rs.getInt("BASE_DURATION"));

.....

return cost;

}

2）配置文件applicationContext.xml

<property name="driverClassName"

value="oracle.jdbc.driver.OracleDriver"></property>

<property name="url"

value="jdbc:oracle:thin:@172.17.3.6:1521:ora10g"></property>

<!-- initialSize:连接池创建的时候,初始化连接数量,不配置默认是0个

maxWait:如果没有连接，最长的等待时间，单位是毫秒数

maxActive:连接池在同一时间内分配最大的使用连接数量-->

</bean>

<!-- 该实现DataSource接口的BasicDataSource注入到dao当中

创建JdbcTemplate对象时，需要传入参数DataSource -->

</bean>

</beans>

3）DAO层

接口

public interface CostDao {

void saveCost(Cost cost);

void deleteCost(Cost cost);

void updateCost(Cost cost);

Cost findById(int id);

List<Cost> findAll();

long findCount();

//查询最高(unit_cost,最低unit_cost,平均unit_cost)

Map findUnitCost();

}

实现类

public class CostDaoImpl implements CostDao{

private JdbcTemplate jdbcTemplate;

//通过外界注入参数（数据库连接参数）

public void setDataSource(DataSource datasource){

jdbcTemplate=new JdbcTemplate(datasource);

}

public void deleteCost(Cost cost) {

String sql="delete from COST_QIN where id=?";

jdbcTemplate.update(sql, new Object[]{cost.getId()});

//第一个参数放sql语句，第二个参数放对象数组，里面放入？对应的值

}

public List<Cost> findAll() {

String sql="select * from COST_QIN";

return jdbcTemplate.query(sql,new CostMapper());

}

public Cost findById(int id) {

String sql="select * from cost_qin where id=?";

RowMapper costMapper=new CostMapper();

return (Cost)jdbcTemplate.queryForObject

(sql, new Object[]{id}, costMapper);

}

public void saveCost(Cost cost) {

String sql="insert into COST_QIN(ID,NAME,BASE_DURATION,

BASE_COST,UNIT_COST,STATUS,DESCR,CREATIME,

STARTIME,COST_TYPE) " +

"values(COST_SEQ.NEXTVAL,?,?,?,?,?,?,?,?,?) ";

jdbcTemplate.update(sql, new Object[]{cost.getName(),cost.getBaseCost(),

cost.getBaseCost(),cost.getUnitCost(),cost.getStatus(),cost.getDescr(),cost.get

CreateTime(),cost.getStartTime(),cost.getCostType()});

}

public void updateCost(Cost cost) {

String sql="update COST_QIN set NAME=?,BASE_DURATION=?,

BASE_COST=?,UNIT_COST=?,STATUS=?,DESCR=?,

CREATIME=?,STARTIME=?,COST_TYPE=? WHERE ID=?";

jdbcTemplate.update(sql, new Object[]{cost.getName(),cost.getBaseCost(),

cost.getBaseCost(),cost.getUnitCost(),cost.getStatus(),cost.getDescr(),cost.get

CreateTime(),cost.getStartTime(),cost.getCostType(),cost.getId()});

}

public long findCount() {

//sql语句当中，切记尽量少出现"*"

//一般对于数据的都用long类型

String sql="select count(id) from cost_qin";

return jdbcTemplate.queryForLong(sql);

}

public Map findUnitCost() {

String sql="select max(unit_cost),min(unit_cost),avg(unit_cost)

from cost_qin";

return jdbcTemplate.queryForMap(sql);

}

4）测试类

public class TestSpring {

public void test1(){

BeanFactory factory=new

ClassPathXmlApplicationContext("applicationContext.xml");

CostDao costDao=(CostDao) factory.getBean("costDao");

Cost cost=new Cost();

cost.setId(168);

costDao.deleteCost(cost);

}

....

6、DaoSupport

是spring提供专门用来Dao层公共抽象类，spring建议程序员在写Dao层，

所有的类最好都继承DaoSupport下属子类。

1）针对jdbc：继承JdbcDaoSupport

JdbcDaoSupport：内部包含一个JdbcTemplate对象，以简化操作。

可以通过 getJdbcTemplate()方法获得JdbcTemplate对象

public abstract class JdbcDaoSupport extends DaoSupport {

private JdbcTemplate jdbcTemplate;

public final void setDataSource(DataSource dataSource) {

if (this.jdbcTemplate == null || dataSource !=

this.jdbcTemplate.getDataSource()) {

this.jdbcTemplate = createJdbcTemplate(dataSource);

initTemplateConfig();

}

public final JdbcTemplate getJdbcTemplate() {

return this.jdbcTemplate;

}

之所以要继承JdbcDaoSupport，主要是因为JdbcDaoSupport类中有一个属性

JdbcTemplate。不继承也可以，在dao实现类中添加属性JdbcTemplate

2）针对hibernate：继承HibernateDaoSupport

包含一个hibernateTemplate

spring建议使用hibernate做开发的时候，dao最好继承

HibernateDaoSupport,以便利用里面工具类hibernateTemplate

7、修改Dao实现类，采用继承JdbcDaoSupport方式

public class CostDaoImpl extends JdbcDaoSupport implements CostDao{

// CostDaoImpl 继承了 JdbcDaoSupport类，

//相当于CostDaoImpl有了下面的代码

private JdbcTemplate jdbcTemplate;

public final void setDataSource(DataSource dataSource) {

if (this.jdbcTemplate == null || dataSource !=

this.jdbcTemplate.getDataSource()) {

this.jdbcTemplate = createJdbcTemplate(dataSource);

initTemplateConfig();

}

//有了属性JdbcTemplate，创建JdbcTemplate依然要注入DataSource参数。

//applicationContext.xml配置文件不需要改变

public void deleteCost(Cost cost) {

String sql="delete from COST_QIN where id=?";

this.getJdbcTemplate().update(sql, new Object[]{cost.getId()});

}

public List<Cost> findAll() {

String sql="select * from COST_QIN";

return this.getJdbcTemplate().query(sql,new CostMapper());

}

.....

public Map findUnitCost() {

String sql="select max(unit_cost),min(unit_cost),avg(unit_cost) from cost_qin";

return this.getJdbcTemplate().queryForMap(sql);

}

十、spring整合hibernate

1、spring整合Hibernate步骤

1）导入hibernate的jar包 hibernate常用的版本是3.2或者3.5

2）导入hibernate的配置文件

3）生成对应po类和orm映射文件

4）导入spring的jar包

5）导入spring核心配置文件

2、spring整合hibernate的工具类

HibernateTemplate类

封装了spring针对hibernate的方法，简化hibernate的操作。

该类的构造器

public HibernateTemplate(SessionFactory sessionFactory) {

setSessionFactory(sessionFactory);

afterPropertiesSet();

}

说明在创建HIbernateTemplate对象时，需要传入一个Sessionfactory参数。

public class CostDaoImpl implements CostDao {

private HibernateTemplate hibernateTemplate;

//使用spring的DI依赖注入，使用set注入一个SessionFactory

//让spring管理hibernate的数据源

public void setSessionFactory(SessionFactory sessionFactory){

//创建带sessionFactroy的hibernateTemplate对象

hibernateTemplate = new HibernateTemplate(sessionFactory);

}

3、注入SessionFactory

1、创建hibernateTemplate对象时，需要传入一个参数SessionFactory

SessionFactory代表了hibernate配置文件中的所有信息，sessionfactory只有一份

1）、数据库的连接信息

2）、hibernate自身的属性信息

3）、hibernate映射文件

注意不是注入DataSource，DataSource只是SessionFactory真的一小部分

2、使用spring核心配置文件注入SessionFactroy（第一种方式）

<bean id="sessionFactory"

class="org.springframework.orm.hibernate3.LocalSessionFactoryBean" >

</bean>

</bean>

上述配置注入了一个SessionFactory，

类型为org.springframework.orm.hibernate3.LocalSessionFactoryBean，

部分源代码：

public class LocalSessionFactoryBean extends AbstractSessionFactoryBean

implements BeanClassLoaderAware {

private Configuration configuration;

public void setConfigLocation(Resource configLocation) {

this.configLocations = new Resource[] {configLocation};

}

LocalSessionFactoryBean类中的属性configuration用来用来加载资源文件，

这里加载hibernate配置文件。

3、问题：LocalSessionFactoryBean类型并不是SessionFactory接口类型

（即没有实现Sessionfactory接口），如何实现注入的？

LocalSessionFactoryBean 本身不是一个session factory，但是spring会自动把对这

个bean的引用替换成LocalSessionFactoryBean 里面的真正的session factory。

（1）在LocalSessionFactoryBean 中有个字段是存放真正的session factory的：

LocalSessionFactoryBean 继承了抽象类AbstractSessionFactoryBean

抽象类中有：

public abstract class AbstractSessionFactoryBean

implements FactoryBean, InitializingBean, DisposableBean,

PersistenceExceptionTranslator {

private DataSource dataSource;

private SessionFactory sessionFactory;

public Object getObject(); {

returnthis.sessionFactory;

}

当引用这个LocalSessionFactoryBean 的时候，比如

applicationContext.getBean("localSessionFactoryBean ")这样，spring返回的不是

LocalSessionFactoryBean 本身，他会自动调用getObject()这个方法，把真正的

session factory返回，得到的都是session factory而不是

LocalSessionFactoryBean 。

（2）LocalSessionFactoryBean实现了org.springframework.beans.factory.FactoryBean

接口, spring在装配的时候, 如果发现实现了factory.FactoryBean接口, 就会

使用FactoryBean#getObject() 方法返回的对象装配。

如果你想拿到LocalSessionFactoryBean实例, 在id前面加个'&'就可以了,在你

的配置文件中BeanFactory.getBean('&sessionFactory')拿到的就是

LocalSessionFactoryBean的实例.

4、案例

1）导入hibernate的jar包 hibernate常用的版本是3.2或者3.5

2）导入hibernate的配置文件

<hibernate-configuration>

<session-factory>

<property name="dialect">org.hibernate.dialect.OracleDialect</property>

<propertyname="connection.url">

jdbc:oracle:thin:@172.17.3.6:1521:ora10g</property>

oracle.jdbc.OracleDriver</property>

<!--映射文件->

</session-factory>

</hibernate-configuration>

3）生成对应po类和orm映射文件

public class Cost implements java.io.Serializable {

private Integer id;

private String name;

private Long baseDuration;

private Double baseCost;

private Double unitCost;

private String status;

private String descr;

private Date creatime;

private Date startime;

private String costType;

get/set方法

}

Cost.hbm.xml 省略

4）导入spring的jar包

5）导入spring核心配置文件

配置文件applicationContext.xml

<bean id="sessionFactory"

class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">

<property name="configLocation"

value="classpath:hibernate.cfg.xml"></property>

</bean>

</bean>

</beans>

6）DAO层（注意事务问题，下节讲）

public interface CostDao {

void saveCost(Cost cost);

void deleteById(int id);

void updateCost(Cost cost);

Cost findById(int id);

List<Cost> findAll();

//查询总的cost数量

long findCount();

List<Cost> findPage(int page,int pageSize);

}

第一种方式：添加一个HibernateTemplate类

public class CostDaoImpl implements CostDao{

private HibernateTemplate hibernateTemplate;

public void setSessionFactory(SessionFactory sessionFactory){

hibernateTemplate=new HibernateTemplate(sessionFactory);

}

public void saveCost(Cost cost) {

//不要使用hql语句，hql语句可以查询，修改，删除就不是不能保存

hibernateTemplate.save(cost);

}

public void updateCost(Cost cost) {

hibernateTemplate.save(cost);

}

public Cost findById(int id) {

return (Cost) hibernateTemplate.get(Cost.class, id);

}

public List<Cost> findAll() {

//spring整合hibernate时，查询方法一般使用find方法，find方法返回一

//般都是list集合，spring没有整合uniqueResult，

//如果使用hql查询，使用find，返回永远都是list

//这是spring整合hibernate不太成功之一

String hql="from Cost";

return hibernateTemplate.find(hql);

}

public long findCount() {

String hql="select count(id) from Cost";

//最好先变成string再转成int。不要强转，spring的版本不同，返回可能

//是Long，Integer类型

List list=hibernateTemplate.find(hql);

long count=Long.parseLong(list.get(0).toString());

return count;

}

public List<Cost> findPage(final int page,final int pageSize) {

final String hql="from Cost";

//spring整合hibernate的时候，对分页没有很好的支持

//必须要使用hibernate中的session来实现分页

//使用回调的方式(固定写法，必须记住)

return (List<Cost>) hibernateTemplate.execute(new HibernateCallback() {

//内部类使用外界的变量的时候，外界变量必须使用final修饰

@Override

public Object doInHibernate(org.hibernate.Session session)

throws HibernateException, SQLException {

int begin=(page-1)*pageSize;

returnsession.createQuery(hql)

.setFirstResult(begin).setMaxResults(pageSize).list();

}

});

}

public void deleteById(int id) {

Cost cost=new Cost();

cost.setId(id);

hibernateTemplate.delete(cost);

}

第二种方式：继承HibernateDaoSupport类

public class CostDaoImpl extends HibernateDaoSupport implements CostDao{

public void saveCost(Cost cost) {

this.getHibernateTemplate().save(cost);

}

public void updateCost(Cost cost) {

this.getHibernateTemplate().save(cost);

}

public Cost findById(int id) {

return (Cost)this.getHibernateTemplate().get(Cost.class, id);

}

public List<Cost> findAll() {

String hql="from Cost";

return this.getHibernateTemplate().find(hql);

}

public long findCount() {

String hql="select count(id) from Cost";

List list=this.getHibernateTemplate().find(hql);

long count=Long.parseLong(list.get(0).toString());

return count;

}

public List<Cost> findPage(final int page,final int pageSize) {

final String hql="from Cost";

return (List<Cost>) this.getHibernateTemplate().

execute(new HibernateCallback() {

public Object doInHibernate(org.hibernate.Session session)

throws HibernateException, SQLException {

int begin=(page-1)*pageSize;

return session.createQuery(hql)

.setFirstResult(begin).setMaxResults(pageSize).list();

}

});

}

public void deleteById(int id) {

Cost cost=new Cost();

cost.setId(id);

this.getHibernateTemplate().delete(cost);

}

5、spring+hibernate如何使用Session、Query等对象

（1）方式一

利用HIbernateDaoSupport提供的getSession方法。

没用到延迟加载的API，那么用这个方式简单些。但是有延迟加载的API，则会

出现问题：session关闭早了，页面可能获取不到数据；不关闭，一旦出了方法体

则关不上了。而多次访问数据库后，就发现没结果，因为连接数用完了。

Session session = getSession();

..............利用session进行一些操作.......

session.close();//注意：一定要释放

getHibernateTemplate中的API都有释放操作，所以自己不用再写。

（2）方式二

利用HibernateTemplate.execute()方法，以回调函数方式使用。这种方式不用担心

方式一出现的问题，session的关闭由HibernateTemplate统一管理。

getHibernateTemplate().execute(

new HibernateCallBack(Session session){

public Object doInHibernate()throws HibernateException,SQLException{

//回调函数中使用session

}

);

6、spring配置SessionFactory的第2中方式（更常用）

修改applicationContext.xml文件

将hibernate.cfg.xml文件去掉，把该文件的信息配置到applicationContext.xml文件中。

添加数据连接池的配置

<!-- 配置SessionFactory的第二种方式(企业项目上线的时候)

主要配置的是3部分参数

1）DataSource（连接池对象）

2）hibernate属性

3）orm映射文件 -->

<property name="driverClassName"

value="oracle.jdbc.OracleDriver"></property>

<property name="url"

value="jdbc:oracle:thin:@172.17.3.6:1521:ora10g"></property>

</bean>

<bean id="sessionFactory"

class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">

<props>

org.hibernate.dialect.OracleDialect</prop>

</props>

</property>

<list>

<value>com/tarena/pojo/Cost.hbm.xml</value>

</list>

</property>

</bean>

</bean>

</beans>

十一、spring事务管理

JDBC的底层是默认自动提交事务，每次执行JDBC都会在底层默认提交事务。HIbernate底层是默认手动提交事务，需要我们程序员自己去提交事务。

真实企业开发中：需要我们控制事务的提交，回滚等，比如银行转账，减钱和加钱同时提交事务才可以。

1、事务的传播特性

1）事务边界

比如银行转账，减钱开始前和加钱结束后就是事务边界，共用同一个事务。

2）事务的传播特性

事务的传播特性是指连续一次或者多次对数据库的操作，事务的控制。

指多次对数据进行操作时，如何对事务进行控制就是事务的传播特性。

对事务进行控制就是指控制什么时候开启，什么时候提交，什么时候回滚。

（1）propagation_required 数据库操作1 数据库操作2 数据库操作3 ...

连续两次或者多次操作数据库，都沿用同一个事务。

如果存在一个事务，则支持当前事务，如果没有事务，则开启一个事务。

比如：第一次查询没有事务，第二次删除操作，开启事务，第三次是修改操作，

沿用删除操作开启的事务。

增删改是required特性，必须要有事务。

（2）propagation_not_supported

非事务执行。一般用于查询操作（比如分页查询）

（3）企业开发中，一般增删改操作配置成required，查询配置成not_supported

2、事务的隔离级别

脏数据（永远不要出现）：读到没有提交的数据。脏读就是读取没提交的数据

不可重复读：数据提交到数据库，可以读数据。

一条数据被修改的同时，另一个人也在修改该数据。

同一时刻，多个人修改同一条数据，读出来的数据和自己修改的数据

不一样

幻象读：整张表数据被修改，又插入一些新数据

一个人对所有数据进行修改时，另一个人又插入一些新数据

一个人访问所有数据的同时又有人添加了一些新数据

脏读一定不能出现，不可重复读和幻象读可以出现

1）read_uncommited

最低的隔离级别，数据没有提交就能读，能看到

企业开发一定尽量不要使用

2）read_commited

提交后才能读（不能脏读）

3）repeatable_read

在我访问某条数据的时候，别人都不能访问，但可以访问其他数据。

不会出现不可重复读，会出现幻觉读（指的是整张表中所有的数据）

4）serializable

整张表在同一时刻只有一个人可以访问，访问结束后其他人才可以访问。

不会出现不可重复读，不会出现幻想读。最昂贵的。

最最常用的隔离级别是read_commited

隔离一定要避免脏读（数据位提交，一定不能读取）

面试问在隔离级别中要避免什么？避免脏读。

spring管理事务就是管理事务的传播特性和隔离级别

3、声明式事务（hibernate版本的）

通过spring配置文件来控制事务

通过spring配置来管理我们的事务（事务的传播特性和事务的隔离级别）。

（1）指定事务管理器

（事务管理器在spring底层来控制事务的对象，开启事务，提交事务，回滚事务等）

类HibernateTransactionManager中管理事务的方法

1）doBegin(){ hibTx = session.beginTransaction();} 开启事务

2）doCommit(){} 提交事务

3）doRollBack(){} 回滚事务

<bean id="transactionManager"

class="org.springframework.orm.hibernate3.HibernateTransactionManager">

</bean>

（2）配置事务特性（方法执行的时候，事务如何控制）

a）事务的传播特性

PROPAGATION_REQUIRED :增删改

PROPAGATION_NOT_SUPPORTED：查询

b）事务的隔离级别

READ_COMMITED

c）配置事务的特性（事务的传播特性和事务的隔离级别）

<!--

transaction-manager指定事务管理器，由transactionManager来管理事务

DEFAULT指的是当前数据库默认的隔离级别

mysql必须修改隔离级别，oracle可以不修改，默认是read_commited

delete*":*匹配后面的任意的名字，比如匹配deleteUser... 其他同理

-->

<tx:advice id="txAdvice" transaction-manager="transactionManager">

<tx:attributes>

<tx:method name="find*" propagation="NOT_SUPPORTED"

read-only="true" isolation="READ_COMMITTED"/>

<tx:method name="save*" propagation="REQUIRED"

isolation="READ_COMMITTED"/>

<tx:method name="delete*" propagation="REQUIRED"

isolation="READ_COMMITTED"/>

<tx:method name="update*" propagation="REQUIRED"

isolation="READ_COMMITTED"/>

</tx:attributes>

</tx:advice>

（3）固定的Aop

<aop:config>

<aop:pointcut expression="execution(* com.tarena.dao..*.*(..))" id="txPointcut"/>

<aop:advisor advice-ref="txAdvice" pointcut-ref="txPointcut"/>

</aop:config>

4、applicationContext.xml（hibernate版本）

将spring整合hibernate的案例添加事务管理

<bean id="sessionFactory"

class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">

<property name="configLocation"

value="classpath:hibernate.cfg.xml"></property>

</bean>

<bean id="transactionManager"

class="org.springframework.orm.hibernate3.HibernateTransactionManager">

</bean>

<tx:advice id="txAdvice" transaction-manager="transactionManager">

<tx:attributes>

<tx:method name="find*" propagation="NOT_SUPPORTED"

read-only="true" isolation="READ_COMMITTED"/>

<tx:method name="save*" propagation="REQUIRED"

isolation="READ_COMMITTED"/>

<tx:method name="delete*" propagation="REQUIRED"

isolation="READ_COMMITTED"/>

<tx:method name="update*" propagation="REQUIRED"

isolation="READ_COMMITTED"/>

</tx:attributes>

</tx:advice>

<aop:config>

<aop:pointcut expression="execution(* com.tarena.dao..*.*(..))" id="txPointcut"/>

<aop:advisor advice-ref="txAdvice" pointcut-ref="txPointcut"/>

</aop:config>

</bean>

</beans>

5、使用注解方式配置事务

1）applicationContext.xml

<bean id="sessionFactory"

class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">

<property name="configLocation"

value="classpath:hibernate.cfg.xml"></property>

</bean>

<!-- 1、指定当前事务的管理器

管理事务事务开启提交回滚 -->

<bean id="transactionManager"

class="org.springframework.orm.hibernate3.HibernateTransactionManager">

</bean>

<!-- 2、开启事务的注解配置

transaction-manager:指明让transactionManager管理事务 -->

<tx:annotation-driven proxy-target-class="true"

transaction-manager="transactionManager"/>

</bean>

</beans>

2）在业务组件的类定以前或方法中使用@Transactional注解即可

public class CostDaoImpl extends HibernateDaoSupport implements CostDao{

@Transactional(isolation=Isolation.READ_COMMITTED,

propagation=Propagation.REQUIRED)

public void saveCost(Cost cost) {

.....

}

@Transactional(isolation=Isolation.READ_COMMITTED,

propagation=Propagation.REQUIRED)

public void updateCost(Cost cost) {

.....

}

@Transactional(isolation=Isolation.READ_COMMITTED,

propagation=Propagation.REQUIRED)

public Cost findById(int id) {

....

}

@Transactional(isolation=Isolation.READ_COMMITTED,

propagation=Propagation.REQUIRED)

public List<Cost> findAll() {

...

}

3）注意事项

如果将Action当作目标，需要在<tx:annotation-driven>添加 proxy-target-class="true"

属性，表示不管有没有接口，都采用CGLIB方式生成代理类。

6、编程式事务管理

基于Java编程实现事务控制，不推荐使用。

主要是利用TransactionTemplate的execute()方法，以回调方式将多个操作封装在一个

事务中。

7、spring针对JDBC的声明式事务

企业开发中，两层架构事务配置在action上，三层架构配置在service上面。

applicationContext.xml文件

</bean>

<bean id="transactionManager"

class="org.springframework.jdbc.datasource.DataSourceTransactionManager">

</bean>

<tx:advice id="txadvice"

transaction-manager="transactionManager">

<tx:attributes>

<tx:method name="find*" propagation="NOT_SUPPORTED" read-only="true"

isolation="READ_COMMITTED"/>

<tx:method name="save*" propagation="REQUIRED"

isolation="READ_COMMITTED" />

<tx:method name="update*" propagation="REQUIRED"

isolation="READ_COMMITTED"/>

<tx:method name="delete*" propagation="REQUIRED"

isolation="READ_COMMITTED" />

</tx:attributes>

</tx:advice>

<aop:config>

<!--事务配置到那个层（Action，dao）是pointcut决定的，

一般来说如果Action，Dao结构，事务一般配置到Action

如果是Action，service，dao结构事务一般配置到service

切记：事务尽量不要配置到dao层，在web项目中

-->

<aop:pointcut expression="execution (* com.tarena.dao..*.*(..))" id="curd"/>

<aop:advisor advice-ref="txadvice" pointcut-ref="curd"/>

</aop:config>

</bean>

</beans>

十二、spring整合struts2

1、struts2 中常量定义

struts2这个框架，在运行本身配置很多的常量，而这些是应用于一般性的开发，这些常

量全部都配置在default.properties。

default.properties文件在struts2-core02.1.8.jar包中 /org/apache/struts2/default.properties

1）# struts.objectFactory = spring :由spring来提供struts2中

action对象的创建及维护，默认情况下给注释了。

struts本身负责创建action对象的类是：StrutsObjectFactory类

2）struts.i18n.encoding=UTF-8 ：struts2默认编码是UTF-8

3）struts.action.extension=action,,

提交的请求的后缀，struts默认情况下可以接收以.action和不加任何后缀结尾的请求

2、修改常量

1）default.properties该文件中定义的常量的信息，可以随意的进行修改，修改方法

在struts.xml中

<constant name="" value=""></constant>重新定义值

eg：<constant name="struts.action.extension" value="do"></constant>。

更改为接收以.do为结尾的请求

2）spring整合struts2，spring管理struts2中的Action对象的创建及维护，

必须要修改default.properties中配置信息

导入一个struts2-spring-plugin-2.0.11.2.jar

有一个配置文件：struts-plugin.xml中

修改default.properties中配置信息，由spring来创建并维护struts2中的Action对象

struts-plugin.xml文件内容

<bean type="com.opensymphony.xwork2.ObjectFactory" name="spring"

class="org.apache.struts2.spring.StrutsSpringObjectFactory" />

指定struts的action对象由spring来创建维护，即StrutsSpringObjectFactory类。

这样struts请求过来时，Action对象将交给整合包spring容器获取，即struts2不再

产生Action对象。

</struts>

3、struts2中默认继承的包struts-default

<default-class-ref class="com.opensymphony.xwork2.ActionSupport" />

默认关联ActionSupport

<result name="success">/WEB-INF/cost/addCost.jsp</result>

</action>

toAddCost请求------》默认关联ActionSupport------》execute方法，返回值是success

4、spring整合struts2

1）原理：把struts2中的action对象的创建和维护，全部交给spring 统一的创建和维护。

必须要导入struts2-spring-plugin-2.0.11.2.jar

自动修改default.properties中的

struts.objectFactory = spring，交由spring来维护action对象

2）什么时候加载spring核心配置？（把spring配置文件中bean全部实例化）

监听器：

启动服务器，就去实例化spring中的bean,提交性能

3）spring 提供加载配置文件的类：

org.springframework.web.context.ContextLoaderListener

4）修改web.xml文件

5、案例整合资费模块

1）首先添加spring，struts2，hibernate的jar包和配置文件

2）对po类，修改成符合hibernate操作的po和orm映射文件

3）修改spring核心配置文件，用来整合hibernate

4）添加spring核心配置文件，用来配置action ，dao

spring整合框架的配置文件最好单独作为一个配置文件

5） spring整合struts2

6）重写CostDaoImpl（spring整合hibernate）

7）重构Action,去掉工厂，使用spring的IOC，提供Action所依赖dao对象

1）导入包

2）po类和orm映射文件

3）applicationContext_hibernate.xml文件

<property name="driverClassName"

value="oracle.jdbc.driver.OracleDriver"></property>

<property name="url"

value="jdbc:oracle:thin:@172.17.3.6:1521:ora10g"></property>

</bean>

<bean id="sessionFactory"

class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">

<props>

org.hibernate.dialect.OracleDialect</prop>

</props>

</property>

<list>

<value>web/netctoss/cost/entity/Cost.hbm.xml</value>

<value>web/netctoss/account/entity/Account.hbm.xml</value>

....

</list>

</property>

</bean>

<bean id="transactionManager"

class="org.springframework.orm.hibernate3.HibernateTransactionManager">

</bean>

<tx:advice id="txAdvice" transaction-manager="transactionManager">

<tx:attributes>

<tx:method name="find*" propagation="NOT_SUPPORTED"

isolation="READ_COMMITTED" read-only="true"/>

<tx:method name="delete*" propagation="REQUIRED"

isolation="READ_COMMITTED"/>

<tx:method name="update*" propagation="REQUIRED"

isolation="READ_COMMITTED"/>

<tx:method name="save*" propagation="REQUIRED"

isolation="READ_COMMITTED"/>

<tx:method name="execute" propagation="REQUIRED"

isolation="READ_COMMITTED"/>

</tx:attributes>

</tx:advice>

<aop:config>

<aop:pointcut expression="execution(* web.netctoss.cost.action.*.*(..) )"

id="costPointcut"/>

<aop:pointcut expression="execution(* web.netctoss.account.action.*.*(..) )"

id="accountPointcut"/>

<aop:pointcut expression="execution(* web.netctoss.service.action.*.*(..) )"

id="servicePointcut"/>

<aop:advisor advice-ref="txAdvice" pointcut-ref="costPointcut"/>

<aop:advisor advice-ref="txAdvice" pointcut-ref="accountPointcut"/>

<aop:advisor advice-ref="txAdvice" pointcut-ref="servicePointcut"/>

</aop:config>

</beans>

4）applicationContext_bean.xml

<!--资费模块模块 action，dao

把struts2中的Action，纳入spring的管理，

struts2中的Action的创建和维护都交给spring统一处理

还有一个问题，struts2中的action是多例，spring中的bean是单例-->

</bean>

<bean id="findCostAction" class="web.netctoss.cost.action.FindCostAction"

scope="prototype">

</bean>

5）action配置文件

<!-- struts中的action对象都是由spring来创建和维护，不用struts2来维护

每一个action中的class属性的值，指向spring生成的Action对象bean的id -->

<interceptor-ref name="netctossStack"></interceptor-ref>

</action>

6）修改action类

public class FindCostAction {

.....输入输出属性

private CostDAO costDao; 依赖注入dao类

public String execute(){

try {

costs=costDao.findByPages(page, pageSize);

totalPage=costDao.findTotalPage(pageSize);

} catch (Exception e) {

e.printStackTrace();

return "error";

}

return "success";

}

7）修改dao类

添加工具类HibernateTemplate类

8）修改web.xml文件

<web-app ...>

<context-param>

<param-name>contextConfigLocation</param-name> <param-value>classpath:applicationContext_*.xml</param-value>

</context-param>

<listener-class>

org.springframework.web.context.ContextLoaderListener

</listener-class>

</listener>

<filter-name>Struts2</filter-name>

<filter-class>

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

</filter-class>

</filter>

<filter-mapping>

<filter-name>Struts2</filter-name>

<url-pattern>/*</url-pattern>

</filter-mapping>

</web-app>

十三、Spring MVC

struts2和webwork是基于过滤器实现的

struts1和spring是基于servlet实现的

struts1的Action，servlet，springMVC的Controller是单例的，struts2的Action是多例的

springMVC流程

1、客户端发送请求

2、客户端发送的请求到达控制器，控制器由Servlet(DispacherServlet)实现的，完成请求的转发

3、该控制器（DispatcherServlet）调用一个用于映射的类HandlerMapping

该类用于将请求映射到对应的处理器来处理请求

4、HandlerMapping将请求映射到对应的处理器Controller（相对于Action）

在Spring当中如果写一些处理器组件，一般实现Controller接口

5、在Controller中就可以调用一些Service或DAO来进行数据操作

6、ModelAndView可以存放从Dao中取出的数据，还可以存放响应视图的一些数据

7、如果想将处理结果返回给用户，那么在Sping框架中还提供了一个视图组件ViewResolver，

该组件根据Controller返回的标识，找到对应的视图，将响应返回给用户

案例

1、新建一个web项目导入jar包

commons-logging.jar spring-webmvc.jar spring.jar

2、web.xml文件

<web-app ...>

<!-- springMVC首先截获所有.do结尾的请求，都交给DispatcherServlet统一处理

DispatcherServlet加载src目录下的spring-mvc.xml配置文件

springMVC的controller是单例

-->

<servlet-name>springMVC</servlet-name>

<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>

<init-param>

<param-name>contextConfigLocation</param-name>

<param-value>classpath:spring-mvc.xml</param-value>

</init-param>

</servlet>

<servlet-mapping>

<servlet-name>springMVC</servlet-name>

<url-pattern>*.do</url-pattern>

</servlet-mapping>

</web-app>

3、login.jsp

<!-- struts1和springMVC所截获.do结尾的请求

struts2的请求后缀可以任意修改 -->

用户名:<input type="text" name="username"><br>

密码:<input type="password" name="password"><br>

<span style="color:red;">${errormessage }</span>

</form>

ok.jsp

<body>

${message }

</body>

4、control

User类

public class User {

//用来保存请求发送的请求数据,

//每一个请求都有一个对应的user对象来保存数据

private String username;

private String password;

get/set方法

}

public class LoginControl extends SimpleFormController{

//核心方法onSubmit，等价于struts2中的execute方法

// servlet中的service(doPost和doGet方法)

//command指代用来保存用户提交请求参数的对象,比如user对象

@Override

protected ModelAndView onSubmit(HttpServletRequest request,

HttpServletResponse response, Object command, BindException errors)

throws Exception {

//1.接收请求参数

User user = (User) command;

//2.判断用户名为liu,密码为123才通过

if(user!=null&&"liu".equals(user.getUsername())&&

"123".equals(user.getPassword())){

//3.用来保存数据,显示到页面中

// ModelAndView表示返回的信息，两部分信息

// ModelAndView(跳转页面的名字,要显示到页面中的信息 ModelMap map = new ModelMap();

map.put("message", user.getUsername()+"登录成功");

return new ModelAndView("ok", map);//

}else{

ModelMap map = new ModelMap();

map.put("errormessage", "登录失败,用户名或者密码错误");

return new ModelAndView("login", map);//

}

5、sprin-mvc.xml

<!-- springMVC分成3个部分

第一部分controlBean

第二部分映射关系HandleMapping

第三部分跳转信息 -->

</bean>

<bean id="urlHandlerMapping"

class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">

<props>

<prop key="login.do">loginControl</prop>

</props>

</property>

</bean>

<bean id="viewResolver"

class="org.springframework.web.servlet.view.InternalResourceViewResolver">

</bean>