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

最新推荐文章于 2019-03-19 09:40:37 发布

danny1991

最新推荐文章于 2019-03-19 09:40:37 发布

阅读量532

点赞数

分类专栏： spring学习之路

本文链接：https://blog.csdn.net/danny1991/article/details/50389351

版权

spring学习之路专栏收录该内容

5 篇文章 0 订阅

订阅专栏

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 @Compotent
public 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 @Transactional
public 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的事务管理器
@CustomerTransactional
public 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 @Transactional
public class PersonServiceBean implements PersonService {
	private JdbcTemplate jdbcTemplate;
	@Resource
	public 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.Driver
chat.url=jdbc:mysql://localhost:3306/test2
chat.username=root
chat.password=1234


hibernate.dialect=org.hibernate.dialect.MySQL5Dialect
hibernate.show_sql=true
hibernate.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=true
hibernate.cache.use_query_cache=false
hibernate.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
@Transactional
public 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！

danny1991

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Spring学习第二天——代理对象，AOP，Spring与JDBC结合，spring要与hibernate版本对应

AOP:访问——>代理对象(判断)——>目标对象执行1、AOP——代理对象静态代理，动态代理。多用动态代理横切性关注点：拦截与相应的处理(1)、传统代理对象JDK的代理类创建代理对象：Proxy，要求目标对象必须实现了接口！JDKProxyFactory.java：package cn.itcast.aop;import java.lang.reflec
复制链接

扫一扫

专栏目录