Spring学习第二天——代理对象，AOP，Spring与JDBC结合，spring要与hibernate版本对应

来源：互联网发布：淘宝赠运费险什么意思编辑：程序博客网时间：2024/05/19 14:51

AOP:访问——>代理对象(判断)——>目标对象执行

1、AOP——代理对象

静态代理，动态代理。多用动态代理

横切性关注点：拦截与相应的处理

(1)、传统代理对象

JDK的代理类创建代理对象：Proxy，要求目标对象必须实现了接口！

JDKProxyFactory.java：

package cn.itcast.aop;import java.lang.reflect.InvocationHandler;import java.lang.reflect.Method;import java.lang.reflect.Proxy;import cn.itcast.service.impl.PersonServiceBean;public class JDKProxyFactory implements InvocationHandler{private Object targetObject;public Object createProxyIntance(Object targetObject){this.targetObject = targetObject;/** 第一个参数设置代码使用的类装载器,一般采用跟目标类相同的类装载器* 第二个参数设置代理类实现的接口* 第三个参数设置回调对象,当代理对象的方法被调用时,会委派给该参数指定对象的invoke方法*/return Proxy.newProxyInstance(this.targetObject.getClass().getClassLoader(), this.targetObject.getClass().getInterfaces(), this);}public Object invoke(Object proxy, Method method, Object[] args)throws Throwable {//环绕通知PersonServiceBean bean = (PersonServiceBean) this.targetObject;Object result = null; if(bean.getUser()!=null){//..... advice()-->前置通知try {result = method.invoke(targetObject, args);// afteradvice() -->后置通知} catch (RuntimeException e) {//exceptionadvice()--> 例外通知}finally{//finallyadvice(); -->最终通知}}return result;}}

接口不是类，不能使用new 运算符实例化一个接口。如 x=new comparable（......）;//这个是错误来的。但是可以声明接口变量Comparable x; //这是允许的。

测试app：

@Test public void proxyTest(){JDKProxyFactory factory = new JDKProxyFactory();PersonService service = (PersonService) factory.createProxyIntance(new PersonServiceBean("xxx"));service.save("888");}

如果没有实现接口，那么可以使用第三方：CGLIB生成代理

public class CGLIBProxy implements MethodInterceptor {private Object targetObject;//代理的目标对象public Object createProxyInstance(Object targetObject){this.targetObject = targetObject;Enhancer enhancer = new Enhancer();//该类用于生成代理对象enhancer.setSuperclass(this.targetObject.getClass());//设置父类enhancer.setCallback(this);//设置回调用对象为本身return enhancer.create();}public Object intercept(Object proxy, Method method, Object[] args,MethodProxy methodProxy) throws Throwable {return methodProxy.invoke(this.targetObject, args);}}

测试app：

@Test public void proxyTest2(){CGlibProxyFactory factory = new CGlibProxyFactory();PersonServiceBean service = (PersonServiceBean) factory.createProxyIntance(new PersonServiceBean("xxx"));service.save("999");}

Aspect(切面):指横切性关注点的抽象即为切面,它与类相似,只是两者的关注点不一样,类是对物体特征的抽象,而切面横切性关注点的抽象.

joinpoint(连接点):所谓连接点是指那些被拦截到的点。在spring中,这些点指的是方法,因为spring只支持方法类型的连接点,实际上joinpoint还可以是field或类构造器)

Pointcut(切入点):所谓切入点是指我们要对那些joinpoint进行拦截的定义.

Advice(通知):所谓通知是指拦截到joinpoint之后所要做的事情就是通知.通知分为前置通知,后置通知,异常通知,最终通知,环绕通知

Target(目标对象):代理的目标对象

Weave(织入):指将aspects应用到target对象并导致proxy对象创建的过程称为织入.

Introduction(引入):在不修改类代码的前提下, Introduction可以在运行期为类动态地添加一些方法或Field(是代理对象).

spring就是利用上面的两种方式进行的代理封装(实现了接口就使用JDK的，没实现接口的就采用CGLIB)。

(2)、Spring中的AOP

Spring提供了两种切面声明方式，实际工作中我们可以选用其中一种：

基于XML配置方式声明切面。
基于注解方式声明切面。

注解方式：

<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"       xsi:schemaLocation="http://www.springframework.org/schema/beans           http://www.springframework.org/schema/beans/spring-beans-2.5.xsd           http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd"> <aop:aspectj-autoproxy/></beans>

基于注解方式声明切面：

@Aspect @Compotentpublic class LogPrint {@Pointcut("execution(* cn.itcast.service..*.*(..))")private void anyMethod() {}//声明一个切入点@Before("anyMethod() && args(userName)")//定义前置通知public void doAccessCheck(String userName) {}@AfterReturning(pointcut="anyMethod()",returning="revalue")//定义后置通知public void doReturnCheck(String revalue) {}@AfterThrowing(pointcut="anyMethod()", throwing="ex")//定义例外通知    public void doExceptionAction(Exception ex) {}@After("anyMethod()")//定义最终通知public void doReleaseAction() {}@Around("anyMethod()")//环绕通知public Object doBasicProfiling(ProceedingJoinPoint pjp) throws Throwable {return pjp.proceed();}}

*代表的是返回值的类型（所有类型）
cn.itcast.service.. 包名，子包底下的类也进行拦截
*.*(..) 所有的类、所有的方法、任意参数

@Pointcut("execution (* cn.itcast.service.impl.PersonServiceBean.*(..))")

出现意外通知，后置通知就不会执行了。

@Aspect<pre name="code" class="java">@Compotent

public class MyInterceptor {@Pointcut("execution (* cn.itcast.service.impl.PersonServiceBean.*(..))")private void anyMethod() {}//声明一个切入点@Before("anyMethod() && args(name)")//同时满足public void doAccessCheck(String name) {System.out.println("前置通知"+ name);}@AfterReturning(pointcut="anyMethod()",returning="result")public void doAfterReturning(String result) {System.out.println("后置通知"+ result);}@After("anyMethod()")public void doAfter() {System.out.println("最终通知");}@AfterThrowing(pointcut="anyMethod()",throwing="e")public void doAfterThrowing(Exception e) {System.out.println("例外通知"+ e);}@Around("anyMethod()")public Object doBasicProfiling(ProceedingJoinPoint pjp) throws Throwable {//if(){//判断用户是否在权限System.out.println("进入方法");Object result = pjp.proceed();System.out.println("推出方法");//}return result;}}

XML配置方式：

先声明一个切面类：

public class LogPrint {public void doAccessCheck() {}定义前置通知public void doReturnCheck() {}定义后置通知    public void doExceptionAction() {}定义例外通知public void doReleaseAction() {}定义最终通知public Object doBasicProfiling(ProceedingJoinPoint pjp) throws Throwable {return pjp.proceed();环绕通知}}

再配置xml文件如下：

<bean id="orderservice" class="cn.itcast.service.OrderServiceBean"/><bean id="log" class="cn.itcast.service.LogPrint"/><aop:config>  <aop:aspect id="myaop" ref="log">  <aop:pointcut id="mycut" expression="execution(* cn.itcast.service..*.*(..))"/>  <aop:before pointcut-ref="mycut" method="doAccessCheck"/>  <aop:after-returning pointcut-ref="mycut" method="doReturnCheck "/>  <aop:after-throwing pointcut-ref="mycut" method="doExceptionAction"/>  <aop:after pointcut-ref="mycut" method=“doReleaseAction"/>  <aop:around pointcut-ref="mycut" method="doBasicProfiling"/>  </aop:aspect></aop:config>

！void 除了void类型意外的其他类型

2、spring与JDBC

命名空间：

<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:context="http://www.springframework.org/schema/context"       xmlns:tx="http://www.springframework.org/schema/tx"       xsi:schemaLocation="http://www.springframework.org/schema/beans           http://www.springframework.org/schema/beans/spring-beans-2.5.xsd           http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd           http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd           http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd"></beans>

(1)、数据源的配置：

 <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">    <property name="driverClassName" value="org.gjt.mm.mysql.Driver"/>    <property name="url" value="jdbc:mysql://localhost:3306/itcast?useUnicode=true&characterEncoding=UTF-8"/>    <property name="username" value="root"/>    <property name="password" value="123456"/>     <!-- 连接池启动时的初始值 --> <property name="initialSize" value="1"/> <!-- 连接池的最大值 --> <property name="maxActive" value="500"/> <!-- 最大空闲值.当经过一个高峰时间后，连接池可以慢慢将已经用不到的连接慢慢释放一部分，一直减少到maxIdle为止 --> <property name="maxIdle" value="2"/> <!--  最小空闲值.当空闲的连接数少于阀值时，连接池就会预申请去一些连接，以免洪峰来时来不及申请 --> <property name="minIdle" value="1"/>  </bean>

(2)、配置事务：

(A)、利用注解方式(推荐使用)：

<bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">  <property name="dataSource" ref="dataSource"/></bean>  <!– 采用@Transactional注解方式使用事务  -->  <tx:annotation-driven transaction-manager="txManager"/>@Service @Transactionalpublic class PersonServiceBean implements PersonService {}

@Transactional标注的位置
@Transactional注解可以标注在类和方法上，也可以标注在定义的接口和接口方法上。
如果我们在接口上标注@Transactional注解，会留下这样的隐患：因为注解不能被继承，所以业务接口中标注的@Transactional注解不会被业务实现类继承。所以可能会出现不启动事务的情况。所以，Spring建议我们将@Transaction注解在实现类上。
在方法上的@Transactional注解会覆盖掉类上的@Transactional。

@Transactional之value
value这里主要用来指定不同的事务管理器；主要用来满足在同一个系统中，存在不同的事务管理器。比如在Spring中，声明了两种事务管理器txManager1, txManager2.
然后，用户可以根据这个参数来根据需要指定特定的txManager.
那有同学会问什么情况下会存在多个事务管理器的情况呢？比如在一个系统中，需要访问多个数据源或者多个数据库，则必然会配置多个事务管理器的。

如果我们要程序中使用多个事务管理器（主要是针对多数据源的情况），可以通过以下的方式实现：
Service代码：

public class MultiTxService {    @Transactional("tran_1")    public void addTest(int id){             }    @Transactional("tran_2")    public void deleteTest(int id){             } }

applicationContext.xml配置如下：

<bean id="tran_1"    class="org.springframework.jdbc.datasource.DataSourceTransactionManager"    p:dataSource-ref="dataSource">    <qualifier value="tran_1"/></bean><bean id="tran_2"    class="org.springframework.jdbc.datasource.DataSourceTransactionManager"    p:dataSource-ref="dataSource">    <qualifier value="tran_2"/></bean>

经过以上的代码，每个事务都会绑定各自的独立的数据源，进行各自的事务管理。我们可以优化下以上代码，可以自定义一个绑定到特定事务管理器的注解，然后直接使用这个自定义的注解进行标识：

@Target({ElementType.METHOD,ElementType.TYPE})@Retention(RetentionPolicy.RUNTIME)@Transactional("tran_1")public @interface CustomerTransactional { }

在Service代码中使用：

//使用名为tran_1的事务管理器@CustomerTransactionalpublic void addTest(String str){     }…

使用JdbcTemplate进行insert/update/delete操作：

package cn.itcast.service.impl;import java.util.List;import javax.sql.DataSource;import org.springframework.jdbc.core.JdbcTemplate;import org.springframework.transaction.annotation.Transactional;import cn.itcast.bean.Person;import cn.itcast.service.PersonService;@Service @Transactionalpublic class PersonServiceBean implements PersonService {private JdbcTemplate jdbcTemplate;@Resourcepublic void setDataSource(DataSource dataSource) {this.jdbcTemplate = new JdbcTemplate(dataSource);}public void delete(Integer personid) {jdbcTemplate.update("delete from person where id=?", new Object[]{personid},new int[]{java.sql.Types.INTEGER});}public Person getPerson(Integer personid) {return (Person)jdbcTemplate.queryForObject("select * from person where id=?", new Object[]{personid}, new int[]{java.sql.Types.INTEGER}, new PersonRowMapper());}@SuppressWarnings("unchecked")public List<Person> getPersons() {return (List<Person>)jdbcTemplate.query("select * from person", new PersonRowMapper());}public void save(Person person) {jdbcTemplate.update("insert into person(name) values(?)", new Object[]{person.getName()},new int[]{java.sql.Types.VARCHAR});}public void update(Person person) {jdbcTemplate.update("update person set name=? where id=?", new Object[]{person.getName(), person.getId()},new int[]{java.sql.Types.VARCHAR, java.sql.Types.INTEGER});}}

使用占位符：

<context:property-placeholder location="classpath:jdbc.properties"/> <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close"><property name="driverClassName" value="${driverClassName}"/><property name="url" value="${url}"/><property name="username" value="${username}"/><property name="password" value="${password}"/> <!-- 连接池启动时的初始值 --> <property name="initialSize" value="${initialSize}"/> <!-- 连接池的最大值 --> <property name="maxActive" value="${maxActive}"/> <!-- 最大空闲值.当经过一个高峰时间后，连接池可以慢慢将已经用不到的连接慢慢释放一部分，一直减少到maxIdle为止 --> <property name="maxIdle" value="${maxIdle}"/> <!--  最小空闲值.当空闲的连接数少于阀值时，连接池就会预申请去一些连接，以免洪峰来时来不及申请 --> <property name="minIdle" value="${minIdle}"/> </bean>

Spring管理事务：

RuntimeException会自动回滚
checked的异常不会回滚try catch

可以通过设置来决定是否回滚

@Transactional(rollbackFor=Exception.class)public void delete(Integer personid) throws Exception{jdbcTemplate.update("delete from person where id=?", new Object[]{personid},new int[]{java.sql.Types.INTEGER});throw new Exception("运行期例外");}

查询的时候可以不开启事务：

@Transactional(propagation=Propagation.NOT_SUPPORTED)public Person getPerson(Integer personid) {return (Person)jdbcTemplate.queryForObject("select * from person where id=?", new Object[]{personid}, new int[]{java.sql.Types.INTEGER}, new PersonRowMapper());}

事务传播属性：

REQUIRED：业务方法需要在一个事务中运行。如果方法运行时，已经处在一个事务中，那么加入到该事务，否则为自己创建一个新的事务。(大多数都是这种行为，也是默认行为)
NOT_SUPPORTED：声明方法不需要事务。如果方法没有关联到一个事务，容器不会为它开启事务。如果方法在一个事务中被调用，该事务会被挂起，在方法调用结束后，原先的事务便会恢复执行。
REQUIRESNEW：属性表明不管是否存在事务，业务方法总会为自己发起一个新的事务。如果方法已经运行在一个事务中，则原有事务会被挂起，新的事务会被创建，直到方法执行结束，新事务才算结束，原先的事务才会恢复执行。
MANDATORY：该属性指定业务方法只能在一个已经存在的事务中执行，业务方法不能发起自己的事务。如果业务方法在没有事务的环境下调用，容器就会抛出例外。
SUPPORTS：这一事务属性表明，如果业务方法在某个事务范围内被调用，则方法成为该事务的一部分。如果业务方法在事务范围外被调用，则方法在没有事务的环境下执行。
Never：指定业务方法绝对不能在事务范围内执行。如果业务方法在某个事务中执行，容器会抛出例外，只有业务方法没有关联到任何事务，才能正常执行。
NESTED：如果一个活动的事务存在，则运行在一个嵌套的事务中. 如果没有活动事务, 则按REQUIRED属性执行.它使用了一个单独的事务，这个事务拥有多个可以回滚的保存点。内部事务的回滚不会对外部事务造成影响。它只对DataSourceTransactionManager事务管理器起效

readOnly="true" 事务设置为只读属性

isolation 事务隔离级别
数据库系统提供了四种事务隔离级别供用户选择。不同的隔离级别采用不同的锁类型来实现，在四种隔离级别中，Serializable的隔离级别最高，Read Uncommited的隔离级别最低。大多数据库默认的隔离级别为Read Commited，如SqlServer，当然也有少部分数据库默认的隔离级别为Repeatable Read ，如Mysql

Read Uncommited：读未提交数据(会出现脏读,不可重复读和幻读)。
Read Commited：读已提交数据(会出现不可重复读和幻读)
Repeatable Read：可重复读(会出现幻读)
Serializable：串行化

脏读：一个事务读取到另一事务未提交的更新新据。
不可重复读：在同一事务中，多次读取同一数据返回的结果有所不同。换句话说就是，后续读取可以读到另一事务已提交的更新数据。相反，“可重复读”在同一事务中多次读取数据时，能够保证所读数据一样，也就是，后续读取不能读到另一事务已提交的更新数据。
幻读：一个事务读取到另一事务已提交的insert数据。

(B)、利用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:context="http://www.springframework.org/schema/context"        xmlns:aop="http://www.springframework.org/schema/aop"       xmlns:tx="http://www.springframework.org/schema/tx"       xsi:schemaLocation="http://www.springframework.org/schema/beans           http://www.springframework.org/schema/beans/spring-beans-2.5.xsd           http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd           http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd           http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd"> <context:property-placeholder location="classpath:jdbc.properties"/> <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">    <property name="driverClassName" value="${driverClassName}"/>    <property name="url" value="${url}"/>    <property name="username" value="${username}"/>    <property name="password" value="${password}"/>     <!-- 连接池启动时的初始值 --> <property name="initialSize" value="${initialSize}"/> <!-- 连接池的最大值 --> <property name="maxActive" value="${maxActive}"/> <!-- 最大空闲值.当经过一个高峰时间后，连接池可以慢慢将已经用不到的连接慢慢释放一部分，一直减少到maxIdle为止 --> <property name="maxIdle" value="${maxIdle}"/> <!--  最小空闲值.当空闲的连接数少于阀值时，连接池就会预申请去一些连接，以免洪峰来时来不及申请 --> <property name="minIdle" value="${minIdle}"/> </bean><bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">     <property name="dataSource" ref="dataSource"/>    </bean><aop:config>  <aop:pointcut id="transactionPointcut" expression="execution(* cn.itcast.service..*.*(..))"/>  <aop:advisor advice-ref="txAdvice" pointcut-ref="transactionPointcut"/></aop:config> <tx:advice id="txAdvice" transaction-manager="txManager">  <tx:attributes>    <tx:method name="get*" read-only="true" propagation="NOT_SUPPORTED"/>    <tx:method name="*"/>  </tx:attributes></tx:advice><bean id="personService" class="cn.itcast.service.impl.PersonServiceBean"><property name="dataSource" ref="dataSource"/></bean></beans>

简单的增删查改：

 @Override    public void save(Person person){        Session session = sessionFactory.getCurrentSession();        session.persist(person);    }    @Override    //实体bean已经成为游离状态    public void update(Person person){        Session session = sessionFactory.getCurrentSession();        session.merge(person);    }    @Override    @Transactional(propagation = Propagation.NOT_SUPPORTED,readOnly = true)    public Person getPerson(Integer id){        Session session = sessionFactory.getCurrentSession();        Person person = (Person) session.get(Person.class, id);        return person;    }    @Override    public void delete(Integer id){        Session session = sessionFactory.getCurrentSession();        Person person = (Person) session.load(Person.class, id);        session.delete(person);    }    @Override    @Transactional(propagation = Propagation.NOT_SUPPORTED,readOnly = true)    public List<Person> getPerson(){        Session session = sessionFactory.getCurrentSession();        List<Person> list = session.createQuery("FROM seu.xinci.pojo.Person").list();        return list;    }

3、spring4与hibernate4(加入二级缓存与连接池的配置)

在web容器中实例化spring容器：

通过listener实例化spring容器

<!-- 指定spring的配置文件，默认从web根目录寻找配置文件，我们可以通过spring提供的classpath:前缀指定从类路径下寻找 --><context-param>   <param-name>contextConfigLocation</param-name>   <param-value>classpath:beans.xml</param-value></context-param><!-- 对Spring容器进行实例化 --><listener>      <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class></listener>

作用域整个application范围，如果想要获得spring容器可以通过提供的类进行获得

我们通过下面语句获取spring容器实例：
WebApplicationContext ctx = WebApplicationContextUtils.getWebApplicationContext(this.getServlet().getServletContext());

POM文件：

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">    <modelVersion>4.0.0</modelVersion>    <groupId>com.springapp</groupId>    <artifactId>Spring_test</artifactId>    <packaging>war</packaging>    <version>1.0-SNAPSHOT</version>    <name>Spring_test</name>    <properties>        <spring.version>4.1.1.RELEASE</spring.version>    </properties>    <dependencies>        <dependency>            <groupId>org.springframework</groupId>            <artifactId>spring-core</artifactId>            <version>${spring.version}</version>        </dependency>        <dependency>            <groupId>org.springframework</groupId>            <artifactId>spring-web</artifactId>            <version>${spring.version}</version>        </dependency>        <dependency>            <groupId>javax.servlet</groupId>            <artifactId>servlet-api</artifactId>            <version>2.5</version>        </dependency>        <dependency>            <groupId>javax.servlet.jsp</groupId>            <artifactId>jsp-api</artifactId>            <version>2.1</version>            <scope>provided</scope>        </dependency>        <dependency>            <groupId>org.springframework</groupId>            <artifactId>spring-webmvc</artifactId>            <version>${spring.version}</version>        </dependency>        <dependency>            <groupId>org.springframework</groupId>            <artifactId>spring-test</artifactId>            <version>${spring.version}</version>            <scope>test</scope>        </dependency>        <!-- 数据库的配置 hibernate 映射-->        <dependency>            <groupId>org.springframework</groupId>            <artifactId>spring-orm</artifactId>            <version>${spring.version}</version>        </dependency>        <dependency>            <groupId>junit</groupId>            <artifactId>junit</artifactId>            <version>4.11</version>            <scope>test</scope>        </dependency>        <!-- hibernate配置-->        <dependency>            <groupId>org.hibernate</groupId>            <artifactId>hibernate-core</artifactId>            <version>4.1.1.Final</version>        </dependency>        <!-- 数据源驱动-->        <dependency>            <groupId>org.apache.commons</groupId>            <artifactId>commons-dbcp2</artifactId>            <version>2.1</version>        </dependency>        <!-- 数据库驱动-->        <dependency>            <groupId>mysql</groupId>            <artifactId>mysql-connector-java</artifactId>            <version>5.1.34</version>        </dependency>        <dependency>            <groupId>com.google.code.gson</groupId>            <artifactId>gson</artifactId>            <version>2.3.1</version>        </dependency>    </dependencies>    <build>        <finalName>Spring_test</finalName>        <plugins>            <plugin>                <artifactId>maven-compiler-plugin</artifactId>                <configuration>                    <source>1.6</source>                    <target>1.6</target>                </configuration>            </plugin>            <plugin>                <artifactId>maven-surefire-plugin</artifactId>                <configuration>                    <includes>                        <include>**/*Tests.java</include>                    </includes>                </configuration>            </plugin>        </plugins>    </build></project>

web.xml文件：

<web-app version="2.4"xmlns="http://java.sun.com/xml/ns/j2ee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd"><!-- 在web.xml文件实例化--><context-param><param-name>contextConfigLocation</param-name><param-value>classpath:mvc-dispatcher-servlet.xml</param-value></context-param><listener><listener-class>org.springframework.web.context.ContextLoaderListener</listener-class></listener><!--<servlet-mapping><servlet-name>default</servlet-name><url-pattern>/static/*</url-pattern></servlet-mapping>--><!-- 字符utf-8 --><filter><filter-name>encodingFilter</filter-name><filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class><init-param><param-name>encoding</param-name><param-value>UTF-8</param-value></init-param><init-param><param-name>forceEncoding</param-name><param-value>true</param-value></init-param></filter><filter-mapping><filter-name>encodingFilter</filter-name><url-pattern>/*</url-pattern></filter-mapping><!--<servlet-mapping><servlet-name>default</servlet-name><url-pattern>/static/*</url-pattern></servlet-mapping>--><servlet><servlet-name>spring</servlet-name><servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class><init-param><param-name>contextConfigLocation</param-name><param-value>classpath:mvc-dispatcher-servlet.xml</param-value></init-param><load-on-startup>1</load-on-startup></servlet><servlet-mapping><servlet-name>spring</servlet-name><url-pattern>/</url-pattern></servlet-mapping></web-app>

mvc-dispatcher-servlet.xml：

<beans xmlns="http://www.springframework.org/schema/beans"       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/context http://www.springframework.org/schema/context/spring-context.xsd">    <context:component-scan base-package="seu.xinci"/>    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">        <property name="prefix" value="/WEB-INF/pages/"/>        <property name="suffix" value=".jsp"/>    </bean>    <!-- 加载配置文件 -->    <bean            class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">        <property name="locations">            <list>                <value>classpath:data.properties</value>            </list>        </property>    </bean>    <import resource="classpath:spring-data.xml"></import>    <bean id="personService" class="seu.xinci.service.impl.PersonServiceBean"></bean></beans>

spring-data.xml：

<beans xmlns="http://www.springframework.org/schema/beans"       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"       xmlns:context="http://www.springframework.org/schema/context" xmlns:tx="http://www.springframework.org/schema/tx"       xsi:schemaLocation="http://www.springframework.org/schema/beans        http://www.springframework.org/schema/beans/spring-beans.xsd        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd">    <bean id="dataSource"          class="org.apache.commons.dbcp2.BasicDataSource" destroy-method="close">        <property name="driverClassName" value="${chat.driverClassName}"/>        <property name="url" value="${chat.url}"/>        <property name="username" value="${chat.username}"/>        <property name="password" value="${chat.password}"/>        <!-- 连接池启动时的初始值 -->        <property name="initialSize" value="1"/>        <!-- 连接池的最大值 -->        <property name="maxTotal" value="500"/>        <!-- 最大空闲值.当经过一个高峰时间后，连接池可以慢慢将已经用不到的连接慢慢释放一部分，一直减少到maxIdle为止 -->        <property name="maxIdle" value="2"/>        <!--  最小空闲值.当空闲的连接数少于阀值时，连接池就会预申请去一些连接，以免洪峰来时来不及申请 -->        <property name="minIdle" value="1"/>    </bean>    <!-- 配置session工厂 -->    <bean id="sessionFactory"          class="org.springframework.orm.hibernate4.LocalSessionFactoryBean">        <property name="dataSource" ref="dataSource" />        <property name="packagesToScan">            <list>                <!-- 可以加多个包 -->                <value>seu.xinci.pojo</value>            </list>        </property>        <property name="hibernateProperties">            <props>                <prop key="hibernate.hbm2ddl.auto">${hibernate.hbm2ddl.auto}</prop>                <prop key="hibernate.dialect">${hibernate.dialect}</prop>                <prop key="hibernate.show_sql">${hibernate.show_sql}</prop>                <!-- <prop key="hibernate.current_session_context_class">thread</prop> -->            </props>        </property>    </bean>    <!-- 配置Hibernate事务管理器 -->    <bean id="transactionManager"          class="org.springframework.orm.hibernate4.HibernateTransactionManager">        <property name="sessionFactory" ref="sessionFactory" />    </bean>    <tx:annotation-driven transaction-manager="transactionManager"/></beans>

data.properties：

##chat.driverClassName=com.mysql.jdbc.Driverchat.url=jdbc:mysql://localhost:3306/test2chat.username=rootchat.password=1234hibernate.dialect=org.hibernate.dialect.MySQL5Dialecthibernate.show_sql=truehibernate.hbm2ddl.auto=update

spring4+hibernate4利用注解方式

配置二级缓存：

pom.xml文件：添加三个依赖：

<dependency><groupId>org.hibernate</groupId><artifactId>hibernate-ehcache</artifactId><version>4.1.1.Final</version></dependency><dependency><groupId>org.slf4j</groupId><artifactId>slf4j-api</artifactId><version>1.7.12</version></dependency>

在spring的xml文件中的配置hibernate的session工厂配置处加入下列代码：

第三行尤其重要，因为使用的是hibernate4，与网上大多数的3配置不同

<!-- 二级缓存 --><prop key="hibernate.cache.use_second_level_cache">${hibernate.cache.use_second_level_cache}</prop><prop key="hibernate.cache.use_query_cache">${hibernate.cache.use_query_cache}</prop><prop key="hibernate.cache.region.factory_class">${hibernate.cache.factory_class}</prop>

我使用的是占位符的方式，其中的具体内容如下：

hibernate.cache.use_second_level_cache=truehibernate.cache.use_query_cache=falsehibernate.cache.factory_class=org.hibernate.cache.ehcache.EhCacheRegionFactory

然后在类路径下加入ehcache.xml文件：

<?xml version="1.0" encoding="UTF-8"?><!--     defaultCache节点为缺省的缓存策略     maxElementsInMemory 内存中最大允许存在的对象数量     eternal 设置缓存中的对象是否永远不过期     overflowToDisk 把溢出的对象存放到硬盘上     timeToIdleSeconds 指定缓存对象空闲多长时间就过期,过期的对象会被清除掉     timeToLiveSeconds 指定缓存对象总的存活时间     diskPersistent 当jvm结束是是否持久化对象     diskExpiryThreadIntervalSeconds 指定专门用于清除过期对象的监听线程的轮询时间 --><ehcache>    <diskStore path="D:\cache"/>    <defaultCache  maxElementsInMemory="1000" eternal="false" overflowToDisk="true"        timeToIdleSeconds="120"        timeToLiveSeconds="180"        diskPersistent="false"        diskExpiryThreadIntervalSeconds="60"/><cache name="seu.xinci.pojo.Person" maxElementsInMemory="100" eternal="false"    overflowToDisk="true" timeToIdleSeconds="300" timeToLiveSeconds="600" diskPersistent="false"/></ehcache>

前面的为默认设置，其中自定义了一个特殊的类使用特殊的设置，就是那个seu.xinci.pojo.Person的类。

配置工作都已经完成了，最后别忘记在要进行二级缓存的类上面加注释

@Entity@Cache(usage = CacheConcurrencyStrategy.READ_WRITE)@Table(name = "person")public class Person {}

读写不并发

这样就可以使用了。

spring4+hibernate4解决乱码问题

在web.xml文件中加入以下代码：

<!-- 字符utf-8 --><filter><filter-name>encodingFilter</filter-name><filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class><init-param><param-name>encoding</param-name><param-value>UTF-8</param-value></init-param><init-param><param-name>forceEncoding</param-name><param-value>true</param-value></init-param></filter><filter-mapping><filter-name>encodingFilter</filter-name><url-pattern>/*</url-pattern></filter-mapping>

横跨servlet与jsp

使用spring解决hibernate因session关闭导致的延迟加载例外问题。

<filter>        <filter-name>OpenSessionInViewFilter</filter-name>        <filter-class>org.springframework.orm.hibernate4.support.OpenSessionInViewFilter</filter-class></filter><filter-mapping>        <filter-name>OpenSessionInViewFilter</filter-name>        <url-pattern>/*</url-pattern></filter-mapping>

4、spring4与JPA（加入二级缓存与连接池的配置）

学习完了spring与hibernate后，又出来了一个spring与JPA，但貌似还是用的hibernate的JPA。。。。听说JPA是一种规范，更适合移植，因此又对此作了些研究，好在配置还算简单。

文件结构：

重点是persistence.xml文件的位置，是在类目录下的名叫“META-INF”目录下，名字跟位置都是固定的，不知道为什么，规定

pom.xml文件：

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">    <modelVersion>4.0.0</modelVersion>    <groupId>com.springapp</groupId>    <artifactId>spring_jpa</artifactId>    <packaging>war</packaging>    <version>1.0-SNAPSHOT</version>    <name>spring_jpa</name>    <properties>        <spring.version>4.1.1.RELEASE</spring.version>    </properties>    <dependencies>        <dependency>            <groupId>org.springframework</groupId>            <artifactId>spring-core</artifactId>            <version>${spring.version}</version>        </dependency>        <dependency>            <groupId>org.springframework</groupId>            <artifactId>spring-web</artifactId>            <version>${spring.version}</version>        </dependency>        <dependency>            <groupId>javax.servlet</groupId>            <artifactId>servlet-api</artifactId>            <version>2.5</version>        </dependency>        <dependency>            <groupId>javax.servlet.jsp</groupId>            <artifactId>jsp-api</artifactId>            <version>2.1</version>            <scope>provided</scope>        </dependency>        <dependency>            <groupId>org.springframework</groupId>            <artifactId>spring-webmvc</artifactId>            <version>${spring.version}</version>        </dependency>        <dependency>            <groupId>org.springframework</groupId>            <artifactId>spring-test</artifactId>            <version>${spring.version}</version>            <scope>test</scope>        </dependency>        <dependency>            <groupId>junit</groupId>            <artifactId>junit</artifactId>            <version>4.11</version>            <scope>test</scope>        </dependency>        <!-- 数据库的配置  映射-->        <dependency>            <groupId>org.springframework</groupId>            <artifactId>spring-orm</artifactId>            <version>${spring.version}</version>        </dependency>        <dependency>            <groupId>org.hibernate</groupId>            <artifactId>hibernate-entitymanager</artifactId>            <version>4.1.1.Final</version>        </dependency>        <dependency>            <groupId>org.slf4j</groupId>            <artifactId>slf4j-api</artifactId>            <version>1.7.12</version>        </dependency>        <dependency>            <groupId>mysql</groupId>            <artifactId>mysql-connector-java</artifactId>            <version>5.1.34</version>        </dependency>        <!-- 二级缓存-->        <dependency>            <groupId>org.hibernate</groupId>            <artifactId>hibernate-ehcache</artifactId>            <version>4.1.1.Final</version>        </dependency>        <!-- 连接池-->        <dependency>            <groupId>org.hibernate</groupId>            <artifactId>hibernate-c3p0</artifactId>            <version>4.1.1.Final</version>        </dependency>    </dependencies>    <build>        <finalName>spring_jpa</finalName>        <plugins>            <plugin>                <artifactId>maven-compiler-plugin</artifactId>                <configuration>                    <source>1.6</source>                    <target>1.6</target>                </configuration>            </plugin>            <plugin>                <artifactId>maven-surefire-plugin</artifactId>                <configuration>                    <includes>                        <include>**/*Tests.java</include>                    </includes>                </configuration>            </plugin>        </plugins>    </build></project>

web的配置与前面的配置一样。与hibernate的主要不同是spring的xml文件跟persistence.xml

spring的xml文件：

<beans xmlns="http://www.springframework.org/schema/beans"       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"       xmlns:context="http://www.springframework.org/schema/context" xmlns:tx="http://www.springframework.org/schema/tx"       xsi:schemaLocation="http://www.springframework.org/schema/beans        http://www.springframework.org/schema/beans/spring-beans.xsd        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd">    <context:component-scan base-package="seu.xinci"/>    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">        <property name="prefix" value="/WEB-INF/pages/"/>        <property name="suffix" value=".jsp"/>    </bean>    <bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalEntityManagerFactoryBean">        <property name="persistenceUnitName" value="itcast"/>    </bean>    <bean id="txManager" class="org.springframework.orm.jpa.JpaTransactionManager">        <property name="entityManagerFactory" ref="entityManagerFactory"/>    </bean>    <tx:annotation-driven transaction-manager="txManager"/>    <bean id="personService" class="seu.xinci.service.impl.PersonServiceBean"></bean></beans>

至于perisistence文件个人感觉跟没有与spring结合的hibernate的配置差不多。

<?xml version="1.0"?><persistence xmlns="http://java.sun.com/xml/ns/persistence" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"             xsi:schemaLocation="http://java.sun.com/xml/ns/persistence http://java.sun.com/xml/ns/persistence/persistence_1_0.xsd" version="1.0">    <persistence-unit name="itcast" transaction-type="RESOURCE_LOCAL">        <properties>            <property name="hibernate.dialect" value="org.hibernate.dialect.MySQL5Dialect"/>            <property name="hibernate.connection.driver_class" value="com.mysql.jdbc.Driver"/>            <property name="hibernate.connection.username" value="root"/>            <property name="hibernate.connection.password" value="1234"/>            <property name="hibernate.connection.url" value="jdbc:mysql://localhost:3306/test2"/>            <property name="hibernate.max_fetch_depth" value="3"/>            <property name="hibernate.hbm2ddl.auto" value="update"/>            <property name="hibernate.show_sql" value="true" />            <!-- 连接池的测试-->            <!-- C3P0连接池设定-->            <!-- 使用c3p0连接池  配置连接池提供的供应商-->            <!--<property name="connection.provider_class"></property>-->            <!--在连接池中可用的数据库连接的最少数目 -->            <property name="hibernate.c3p0.min_size" value="5"/>            <!--在连接池中所有数据库连接的最大数目  -->            <property name="hibernate.c3p0.max_size" value="20"/>            <!--设定数据库连接的过期时间,以秒为单位,            如果连接池中的某个数据库连接处于空闲状态的时间超过了timeout时间,就会从连接池中清除 -->            <property name="hibernate.c3p0.timeout" value="120"/>            <!--每3000秒检查所有连接池中的空闲连接 以秒为单位-->            <property name="hibernate.c3p0.idle_test_period" value="3000"/>            <!-- 二级缓存测试-->            <property name="hibernate.cache.use_second_level_cache" value="true" />            <property name="hibernate.cache.use_query_cache" value="false" />            <property name="hibernate.cache.region.factory_class" value="org.hibernate.cache.ehcache.EhCacheRegionFactory"/>        </properties>    </persistence-unit></persistence>

PersonServiceBean:(不是很规范应该写成DAO的)：

package seu.xinci.service.impl;import org.hibernate.Session;import org.hibernate.SessionFactory;import org.springframework.stereotype.Service;import org.springframework.transaction.annotation.Propagation;import org.springframework.transaction.annotation.Transactional;import seu.xinci.pojo.Person;import javax.annotation.Resource;import javax.persistence.EntityManager;import javax.persistence.PersistenceContext;import java.util.List;/** * Created by Administrator on 2015-12-24. */@Service@Transactionalpublic class PersonServiceBean implements seu.xinci.service.PersonService {    @PersistenceContext    EntityManager em;    @Override    public void save(Person person){        em.persist(person);    }    @Override    //实体bean已经成为游离状态    public void update(Person person){        em.merge(person);    }    @Override    @Transactional(propagation = Propagation.NOT_SUPPORTED,readOnly = true)    public Person getPerson(Integer id){        Person person = em.find(Person.class,id);        return person;    }    @Override    @Transactional(propagation = Propagation.NOT_SUPPORTED,readOnly = true)    public Person getPersonByName(String t_name){        Person person = (Person) em.createQuery(                "SELECT t FROM seu.xinci.pojo.Person t WHERE t.name = :u_name ")                .setParameter("u_name", t_name)                .getSingleResult();        return person;    }    @Override    public void delete(Integer id){        em.remove(em.getReference(Person.class, id));    }    @Override    @Transactional(propagation = Propagation.NOT_SUPPORTED,readOnly = true)    public List<Person> getPersons(){        List<Person> list = em.createQuery("SELECT o FROM seu.xinci.pojo.Person o").getResultList();        return list;    }}

测试也都是通过的。

注意：3.5版本之后不用在导入hibernate-annotations.jar这个包,hibernate-core已经集成了.

下面开始spring MVC的学习，fighting！

0 0