spring 2

什么是AOP

1.       面向切面编程Aspect-Oriented-Programming

a)       是对面向对象的思维方式的有力补充

2.       Spring_1400_AOP_Introduction

3.       好处：可以动态的添加和删除在切面上的逻辑而不影响原来的执行代码

a)       Filter

b)       Struts2的interceptor

4.       概念：

a)       JoinPoint

b)       PointCut

c)       Aspect（切面）

d)       Advice

e)       Target

f)        Weave

_________________________________

动态代理

[java]  view plain copy print ?

1. package com.demo.aop;  
2. import java.lang.reflect.InvocationHandler;  
3. import java.lang.reflect.Method;  
4.   
5. public class LogInterceptor implements InvocationHandler {  
6.     private Object target;  
7.       
8.     public Object getTarget() {  
9.         return target;  
10.     }  
11.     public void setTarget(Object target) {  
12.         this.target = target;  
13.     }  
14.     public void beforeMethod(Method m) {  
15.         System.out.println(m.getName() + " start");  
16.     }  
17.     /*Object proxy：指被代理的对象。  
18.     Method method：要调用的方法  
19.     Object[] args：方法调用时所需要的参数  
20.      */  
21.       
22.     @Override  
23.     public Object invoke(Object proxy, Method m, Object[] args)  
24.             throws Throwable {  
25.         beforeMethod(m);  
26.         m.invoke(target, args);  
27.         return null;  
28.     }  
29. }  

[java]  view plain copy print ?

1. package com.demo.dao;  
2.   
3. import com.demo.model.User;  
4.   
5. public interface UserDAO {  
6.     public void save(User u);  
7.       
8.     public void delete();  
9. }  

[java]  view plain copy print ?

1. package com.demo.dao.impl;  
2. import com.demo.dao.UserDAO;  
3. import com.demo.model.User;  
4.   
5. public class UserDAOImpl implements UserDAO {  
6.   
7.     @Override  
8.     public void save(User u) {  
9.         System.out.println("user save");  
10.     }  
11.     @Override  
12.     public void delete() {  
13.         System.out.println("user deleted");  
14.     }  
15. }  

[java]  view plain copy print ?

1. package com.demo.dao.impl;  
2.   
3. import com.demo.dao.UserDAO;  
4. import com.demo.model.User;  
5.   
6. public class UserDAOImpl2 extends UserDAOImpl {  
7.   
8.     @Override  
9.     public void save(User u) {  
10.         System.out.println("save start ....");  
11.         super.save(u);  
12.     }  
13.   
14. }  

[java]  view plain copy print ?

1. package com.demo.dao.impl;  
2.   
3. import com.demo.aop.LogInterceptor;  
4. import com.demo.dao.UserDAO;  
5. import com.demo.model.User;  
6.   
7. public class UserDAOImpl3 extends UserDAOImpl {  
8.   
9.     private UserDAO userDAO = new UserDAOImpl();  
10.       
11.     @Override  
12.     public void save(User u) {  
13.         new LogInterceptor().beforeMethod(null);  
14.         userDAO.save(u);  
15.     }  
16.     public void delete() {  
17.           
18.     }  
19.   
20. }  

[java]  view plain copy print ?

1. package com.demo.service;  
2.   
3. import java.lang.reflect.Proxy;  
4.   
5. import org.junit.Test;  
6.   
7. import com.demo.aop.LogInterceptor;  
8. import com.demo.dao.UserDAO;  
9. import com.demo.dao.impl.UserDAOImpl;  
10. import com.demo.model.User;  
11. import com.demo.spring.BeanFactory;  
12. import com.demo.spring.ClassPathXmlApplicationContext;  
13.   
14. public class UserServiceTest {  
15.       
16.       
17.     @Test  
18.     public void testAdd() throws Exception{  
19.         ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext();  
20.           
21.         UserService service = (UserService)ctx.getBean("userService");  
22.     }  
23.       
24.     @Test  
25.     public void testProxy() {  
26.         UserDAO userDAO = new UserDAOImpl();  
27.         LogInterceptor li = new LogInterceptor();  
28.         li.setTarget(userDAO);  
29.         /*1、第一个参数是说我们要用那个ClassLoader来产生 
30.          * 2、第二个参数是说产生的那些被代理对象它应该是实现那些接口 
31.          * 3、当我产生代理之后调用代理里面的方法，要用那一个handler 进行处理 
32.          * (参数说明：  
33.         ClassLoader loader：类加载器  
34.         Class<?>[] interfaces：得到全部的接口  
35.         InvocationHandler h：得到InvocationHandler接口的子类实例 ) 
36.          * */  
37.           
38.         UserDAO userDAOproxy =  (UserDAO)Proxy.newProxyInstance(userDAO.getClass().getClassLoader(), new Class[]{UserDAO.class}, li);  
39.         userDAOproxy.delete();  
40.         userDAOproxy.save(new User());  
41.     }  
42. }  

[java]  view plain copy print ?

1. aop 标签自动提示配置  
2.   
3. xmlns:aop="http://www.springframework.org/schema/aop"  
4.   
5.  http://www.springframework.org/schema/aop   
6.   
7. http://www.springframework.org/schema/aop/spring-aop-2.5.xsd"  

Spring AOP配置与应用

1.       两种方式：

a)       使用Annotation

b)       使用xml

2.       Annotation

a)       加上对应的xsd文件spring-aop.xsd

b)       beans.xml <aop:aspectj-autoproxy />

c)       此时就可以解析对应的Annotation了

d)       建立我们的拦截类

e)       用@Aspect注解这个类

f)        建立处理方法

g)       用@Before来注解方法

h)       写明白切入点（execution …….）

i)        让spring对我们的拦截器类进行管理@Component

3.       常见的Annotation:

a)       @Pointcut

b)       @Before

c)       @AfterReturning

d)       @AfterThrowing

e)       @After

f)        @Around

4.       织入点语法

a)       void !void

b)       参考文档（* ..）

5.       xml配置AOP

a)       把interceptor对象初始化

b)       <aop:config

                       i.             <aop:aspect …..

1.       <aop:pointcut

2.       <aop:before

<aop:aspectj-autoproxy />  // 自动的帮我产生代理,容器启动过程当中，它扫描到了有这样一个东西，需要产生代理，它就会帮你产生代理

aspectj 专门实现代理的框架

[java]  view plain copy print ?

1. package com.demo.aop;  
2.   
3. import org.aspectj.lang.annotation.Aspect;  
4. import org.aspectj.lang.annotation.Before;  
5. import org.springframework.stereotype.Component;  
6.   
7. @Aspect  //切面  可以把它切到其他的方法上面去  
8. @Component  //初始化 LogInterceptor   
9. public class LogInterceptor {  
10.     @Before("execution(public void com.demo.dao.impl.UserDAOImpl.save(com.demo.model.User))") // 在方法执行之前先执行我这个方法  
11.     public void before() {  
12.         System.out.println("method start");  
13.     }  
14. }  

[java]  view plain copy print ?

1. package com.demo.aop;  
2.   
3. import org.aspectj.lang.annotation.AfterReturning;  
4. import org.aspectj.lang.annotation.Aspect;  
5. import org.aspectj.lang.annotation.Before;  
6. import org.aspectj.lang.annotation.Pointcut;  
7. import org.springframework.stereotype.Component;  
8.   
9. @Aspect  //切面  可以把它切到其他的方法上面去  
10. @Component  //初始化 LogInterceptor   
11. public class LogInterceptor {  
12.     @Pointcut("execution(public * com.demo.dao..*.*(..))")    
13. //  @Pointcut("execution(public * com.demo.service..*.add(..))")  
14.     public void myMethod() {}  
15.   
16.     @Before("myMethod()")  
17.     public void before() {  
18.         System.out.println("method before");  
19.     }  
20.       
21.     @AfterReturning("myMethod()")  
22.     public void afterReturning() {  
23.         System.out.println("method after Returning");  
24.     }  
25.       
26.       
27.       
28.       
29.     /*//@Before("execution(public void com.demo.dao.impl.UserDAOImpl.save(com.demo.model.User))") // 在方法执行之前先执行我这个方法 
30.     @Before("execution(public * com.demo.dao..*.*(..))")  //记住此一个方法即可 
31.     public void before() { 
32.         System.out.println("method before"); 
33.     } 
34.      
35.     @After("execution(public * com.demo.dao..*.*(..))")  //记住此一个方法即可 
36.     public void afterReturning() { 
37.         System.out.println("method after Returning"); 
38.     }*/  
39. }  

        Spring_1600_AOP_XML  （重点）

[html]  view plain copy print ?

1. <?xml version="1.0" encoding="UTF-8"?>  
2. <beans xmlns="http://www.springframework.org/schema/beans"  
3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
4.        xmlns:context="http://www.springframework.org/schema/context"  
5.        xmlns:aop="http://www.springframework.org/schema/aop"  
6.        xsi:schemaLocation="http://www.springframework.org/schema/beans  
7.            http://www.springframework.org/schema/beans/spring-beans-2.5.xsd  
8.            http://www.springframework.org/schema/context  
9.            http://www.springframework.org/schema/context/spring-context-2.5.xsd  
10.            http://www.springframework.org/schema/aop   
11.            http://www.springframework.org/schema/aop/spring-aop-2.5.xsd">  
12.   
13.     <context:annotation-config />  
14.     <context:component-scan base-package="com.demo"/>  
15.       
16.     <bean id="logInterceptor" class="com.demo.aop.LogInterceptor"></bean>  
17.       
18.     <!--<aop:config>  
19.         <aop:pointcut expression="execution(public * com.demo.service..*.add(..))"   
20.             id="servicePointcut"/>  
21.               
22.         <aop:aspect id="logAspect" ref="logInterceptor">  
23.             <aop:before method="before" pointcut-ref="servicePointcut" />  
24.         </aop:aspect>  
25.       
26.     </aop:config>  
27.     -->  
28.       
29.     <aop:config>  
30.         <aop:aspect id="logAspect" ref="logInterceptor">  
31.             <aop:before method="before" pointcut="execution(public * com.demo.service..*.add(..))" />  
32.         </aop:aspect>  
33.       
34.     </aop:config>  
35.       
36. </beans>  

    Spring_1600_Spring_DataSource

[html]  view plain copy print ?

1. <?xml version="1.0" encoding="UTF-8"?>  
2. <beans xmlns="http://www.springframework.org/schema/beans"  
3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
4.        xmlns:context="http://www.springframework.org/schema/context"  
5.        xmlns:aop="http://www.springframework.org/schema/aop"  
6.        xsi:schemaLocation="http://www.springframework.org/schema/beans  
7.            http://www.springframework.org/schema/beans/spring-beans-2.5.xsd  
8.            http://www.springframework.org/schema/context  
9.            http://www.springframework.org/schema/context/spring-context-2.5.xsd  
10.            http://www.springframework.org/schema/aop   
11.            http://www.springframework.org/schema/aop/spring-aop-2.5.xsd">  
12.   
13.     <context:annotation-config />  
14.     <context:component-scan base-package="com.demo"/>  
15.       
16.     <!--  
17.       <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">  
18.       <property name="driverClassName" value="com.mysql.jdbc.Driver"/>  
19.       <property name="url" value="jdbc:mysql://localhost:3306/spring"/>  
20.       <property name="username" value="root"/>  
21.       <property name="password" value="root"/>  
22.       </bean>  
23.     -->  
24.   
25.         <bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">  
26.         <property name="locations">  
27.             <value>classpath:jdbc.properties</value>  
28.         </property>  
29.         </bean>  
30.       
31.         <bean id="dataSource" destroy-method="close"  
32.           class="org.apache.commons.dbcp.BasicDataSource">  
33.         <property name="driverClassName" value="${jdbc.driverClassName}"/>  
34.         <property name="url" value="${jdbc.url}"/>  
35.         <property name="username" value="${jdbc.username}"/>  
36.         <property name="password" value="${jdbc.password}"/>  
37.         </bean>  
38.       
39.     <bean id="logInterceptor" class="com.demo.aop.LogInterceptor"></bean>  
40.       
41. </beans>  

[html]  view plain copy print ?

1. jdbc.driverClassName=com.mysql.jdbc.Driver  
2. jdbcjdbc.url=jdbc:mysql://localhost:3306/spring  
3. jdbc.username=root  
4. jdbc.password=root  

[java]  view plain copy print ?

1. package com.demo.dao.impl;  
2.   
3. import java.sql.Connection;  
4. import java.sql.SQLException;  
5.   
6. import javax.annotation.Resource;  
7. import javax.sql.DataSource;  
8.   
9. import org.springframework.stereotype.Component;  
10.   
11. import com.demo.dao.UserDAO;  
12. import com.demo.model.User;  
13.   
14. @Component("u")  
15. public class UserDAOImpl implements UserDAO {  
16.     private DataSource dataSource;  
17.     public DataSource getDataSource() {  
18.         return dataSource;  
19.     }  
20.     @Resource  
21.     public void setDataSource(DataSource dataSource) {  
22.         this.dataSource = dataSource;  
23.     }  
24.   
25.     @Override  
26.     public void save(User u) {  
27.         Connection conn = null;  
28.         try {  
29.             conn = dataSource.getConnection();  
30.             conn.createStatement().executeUpdate("insert into user values (null,'lisi')");  
31.         } catch (SQLException e) {  
32.             e.printStackTrace();  
33.         } finally {  
34.             try {  
35.                 if(conn != null) {  
36.                     conn.close();  
37.                     conn = null;  
38.                 }  
39.             } catch (SQLException e2) {  
40.                 e2.printStackTrace();  
41.             }  
42.         }  
43.           
44.         System.out.println("user save");  
45.     }  
46.   
47. }  

——————————————————————————————————————————————————————————————————————————

[plain]  view plain copy print ?

1. Spring整合Hibernate  
2. 1.  Spring 指定datasource  
3. a)  参考文档，找dbcp.BasicDataSource  
4. i.  c3p0  
5. ii. dbcp  
6. iii.    proxool  
7. b)  在DAO或者Service中注入dataSource  
8. c)  在Spring中可以使用PropertyPlaceHolderConfigure来读取Properties文件的内容  
9. 2.  Spring整合Hibernate  
10. a)  <bean .. AnnotationSessionFactoryBean>  
11. i.  <property dataSource  
12. ii. <annotatedClasses  
13. b)  引入hibernate 系列jar包  
14. c)  User上加Annotation  
15. d)  UserDAO或者UserServie 注入SessionFactory  
16. e)  jar包问题一个一个解决  
17. 3.  声明式的事务管理  
18. a)  事务加在DAO层还是Service层？  
19. b)  annotation  
20. i.  加入annotation.xsd  
21. ii. 加入txManager bean  
22. iii.    <tx:annotation-driven  
23. iv. 在需要事务的方法上加：@Transactional  
24. v.  需要注意，使用SessionFactory.getCurrentSession 不要使用OpenSession  
25. c)  @Transactional详解  
26. i.  什么时候rollback   
27. 1.  运行期异常，非运行期异常不会触发rollback  
28. 2.  必须uncheck (没有catch)  
29. 3.  不管什么异常，只要你catch了，spring就会放弃管理  
30. 4.  事务传播特性：propagation_required  
31. 5.  read_only  
32. d)  xml（推荐，可以同时配置好多方法）  
33. i.  <bean txmanager  
34. ii. <aop:config   
35. 1.  <aop:pointcut  
36. 2.  <aop:advisor pointcut-ref advice-ref  
37. iii.    <tx:advice: id transaction-manager =   
38. e)  HibernateTemplate、HibernateCallback、HibernateDaoSupport（不重要）介绍  
39. i.  设计模式：Template Method  
40. ii. Callback：回调/钩子函数  
41. iii.    第一种：（建议）  
42. 1.  在spring中初始化HibernateTemplate，注入sessionFactory  
43. 2.  DAO里注入HibernateTemplate  
44. 3.  save写getHibernateTemplate.save();  
45. iv. 第二种：  
46. 1.  从HibernateDaoSupport继承  
47. 2.  必须写在xml文件中，无法使用Annotation，因为set方法在父类中，而且是final的  
48. f)  spring整合hibernate的时候使用packagesToScan属性，可以让spring自动扫描对应包下面的实体类  

1.       Spring 指定datasource

a)       参考文档，找dbcp.BasicDataSource

                       i.             c3p0

                     ii.             dbcp

                   iii.             proxool

b)       在DAO或者Service中注入dataSource

c)       在Spring中可以使用PropertyPlaceHolderConfigure来读取Properties文件的内容

beans.xml 几种dataSource连接方式

[html]  view plain copy print ?

1. <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">  
2.   <property name="driverClassName" value="com.mysql.jdbc.Driver"/>  
3.   <property name="url" value="jdbc:mysql://localhost:3306/spring"/>  
4.   <property name="username" value="root"/>  
5.   <property name="password" value="root"/>  
6.   </bean>  

[html]  view plain copy print ?

1. <bean id="dataSource" destroy-method="close"  
2.           class="org.apache.commons.dbcp.BasicDataSource">  
3.         <property name="driverClassName" value="${jdbc.driverClassName}"/>  
4.         <property name="url" value="${jdbc.url}"/>  
5.         <property name="username" value="${jdbc.username}"/>  
6.         <property name="password" value="${jdbc.password}"/>  
7.         </bean>  

[html]  view plain copy print ?

1. <bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">  
2.    <property name="locations">  
3.        <value>classpath:jdbc.properties</value>  
4.    </property>  
5. </bean>  
6.   
7. <bean id="dataSource" destroy-method="close"  
8.      class="org.apache.commons.dbcp.BasicDataSource">  
9.    <property name="driverClassName" value="${jdbc.driverClassName}"/>  
10.    <property name="url" value="${jdbc.url}"/>  
11.    <property name="username" value="${jdbc.username}"/>  
12.    <property name="password" value="${jdbc.password}"/>  
13. </bean>  

1.       Spring整合Hibernate

a)       <bean .. AnnotationSessionFactoryBean>

                       i.             <property dataSource

                     ii.             <annotatedClasses

b)       引入hibernate 系列jar包

c)       User上加Annotation

d)       UserDAO或者UserServie 注入SessionFactory

e)       jar包问题一个一个解决

下面用hibernate 的sessionFactory连接数据库

[html]  view plain copy print ?

1. <bean id="sessionFactory" class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean">  
2.     <property name="dataSource" ref="dataSource"/>  
3.     <property name="annotatedClasses">  
4.       <list>  
5.         <value>com.demo.model.User</value>  
6.       </list>  
7.     </property>  
8.     <property name="hibernateProperties">  
9.     <props>  
10.         <prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>  
11.             <prop key="hibernate.show_sql">true</prop>  
12.         </props>  
13.     </property>  
14.   </bean>  

[java]  view plain copy print ?

1. package com.demo.dao.impl;  
2.   
3. import javax.annotation.Resource;  
4. import org.hibernate.Session;  
5. import org.hibernate.SessionFactory;  
6. import org.springframework.stereotype.Component;  
7. import com.demo.dao.UserDAO;  
8. import com.demo.model.User;  
9.   
10. @Component("u")  
11. public class UserDAOImpl implements UserDAO {  
12.       
13.     private SessionFactory sessionFactory;  
14.     public SessionFactory getSessionFactory() {  
15.         return sessionFactory;  
16.     }  
17.     @Resource  
18.     public void setSessionFactory(SessionFactory sessionFactory) {  
19.         this.sessionFactory = sessionFactory;  
20.     }  
21.       
22.     @Override  
23.     public void save(User u) {  
24.         Session session = sessionFactory.openSession();  
25.         session.beginTransaction();  
26.         session.save(u);  
27.         session.getTransaction().commit();  
28.         session.close();  
29.         System.out.println("user save");  
30.     }  
31.   
32. }  

org.hibernate.HibernateException: No Hibernate Session bound to thread, and configuration does not allow creation of non-transactional one here    表示这里不能用.getCurrentSession()

[java]  view plain copy print ?

1. @Component("logDAO") //就是spring在为这个类生成对象的时候它的key、id、名字是LgDAO  

1.       声明式的事务管理

a)       事务加在DAO层还是Service层？

b)       annotation

                       i.             加入annotation.xsd

                     ii.             加入txManager bean

                   iii.             <tx:annotation-driven

                   iv.             在需要事务的方法上加：@Transactional

                     v.             需要注意，使用SessionFactory.getCurrentSession不要使用OpenSession

[html]  view plain copy print ?

1. <?xml version="1.0" encoding="UTF-8"?>  
2. <beans xmlns="http://www.springframework.org/schema/beans"  
3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
4.        xmlns:context="http://www.springframework.org/schema/context"  
5.        xmlns:aop="http://www.springframework.org/schema/aop"  
6.        xmlns:tx="http://www.springframework.org/schema/tx"  
7.        xsi:schemaLocation="http://www.springframework.org/schema/beans  
8.            http://www.springframework.org/schema/beans/spring-beans-2.5.xsd  
9.            http://www.springframework.org/schema/context  
10.            http://www.springframework.org/schema/context/spring-context-2.5.xsd  
11.            http://www.springframework.org/schema/aop   
12.            http://www.springframework.org/schema/aop/spring-aop-2.5.xsd  
13.            http://www.springframework.org/schema/tx   
14.            http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">  
15.   
16.     <context:annotation-config />  
17.     <context:component-scan base-package="com.demo"/>  
18.   
19.             <!--  
20.       <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">  
21.       <property name="driverClassName" value="com.mysql.jdbc.Driver"/>  
22.       <property name="url" value="jdbc:mysql://localhost:3306/spring"/>  
23.       <property name="username" value="root"/>  
24.       <property name="password" value="root"/>  
25.       </bean>  
26.     -->  
27.   
28.         <bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">  
29.         <property name="locations">  
30.             <value>classpath:jdbc.properties</value>  
31.         </property>  
32.         </bean>  
33.       
34.         <bean id="dataSource" destroy-method="close"  
35.           class="org.apache.commons.dbcp.BasicDataSource">  
36.         <property name="driverClassName" value="${jdbc.driverClassName}"/>  
37.         <property name="url" value="${jdbc.url}"/>  
38.         <property name="username" value="${jdbc.username}"/>  
39.         <property name="password" value="${jdbc.password}"/>  
40.         </bean>  
41.   
42. <!-- -   <bean id="logInterceptor" class="com.demo.aop.LogInterceptor"></bean> -->  
43.   
44.      <bean id="sessionFactory" class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean">  
45.         <property name="dataSource" ref="dataSource"/>  
46.         <property name="annotatedClasses">  
47.           <list>  
48.             <value>com.demo.model.User</value>  
49.             <value>com.demo.model.Log</value>  
50.           </list>  
51.         </property>  
52.         <property name="hibernateProperties">  
53.         <props>  
54.             <prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>  
55.             <prop key="hibernate.show_sql">true</prop>  
56.          </props>  
57.         </property>  
58.       </bean>  
59.         
60.       <bean id="txManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">  
61.       <property name="sessionFactory" ref="sessionFactory"/>  
62.       </bean>  
63.       
64.       <tx:annotation-driven transaction-manager="txManager"/>  
65.       
66. </beans>  
67.   
68. /*  
69.     @Transactional //运行时异常会回滚  
70.     public void add(User u) {  
71.         this.userDAO.save(u);  
72.         Log log = new Log();  
73.         log.setMsg("a log saved");  
74.         this.logDAO.save(log);  
75.     }  
76. */  

[java]  view plain copy print ?

1. package com.demo.dao;  
2. import com.demo.model.Log;  
3. public interface LogDAO {  
4.     public void save(Log log);  
5. }  

[java]  view plain copy print ?

1. package com.demo.dao.impl;  
2.   
3. import javax.annotation.Resource;  
4. import org.hibernate.Session;  
5. import org.hibernate.SessionFactory;  
6. import org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean;  
7. import org.springframework.stereotype.Component;  
8.   
9. import com.demo.dao.LogDAO;  
10. import com.demo.dao.UserDAO;  
11. import com.demo.model.Log;  
12. import com.demo.model.User;  
13.   
14. @Component //就是spring在为这个类生成对象的时候它的key、id、名字是LgDAO  
15. public class LogDAOImpl implements LogDAO {  
16.     private SessionFactory sessionFactory;  
17.     public SessionFactory getSessionFactory() {  
18.         return sessionFactory;  
19.     }  
20.     @Resource  
21.     public void setSessionFactory(SessionFactory sessionFactory) {  
22.         this.sessionFactory = sessionFactory;  
23.     }  
24.       
25.     @Override  
26.     public void save(Log log) {  
27.         Session session = sessionFactory.getCurrentSession();  
28.         session.save(log);  
29.           
30.         //throw new RuntimeException("Error"); Transaction 事物在运行时异常会回滚  
31.     }  
32.   
33. }  

[java]  view plain copy print ?

1. package com.demo.model;  
2.   
3. import javax.persistence.Entity;  
4. import javax.persistence.GeneratedValue;  
5. import javax.persistence.Id;  
6. import javax.persistence.Table;  
7.   
8. @Entity  
9. @Table(name="t_log")  
10. public class Log {  
11.     private int id;  
12.     private String msg;  
13.       
14.     @Id  
15.     @GeneratedValue  
16.     public int getId() {  
17.         return id;  
18.     }  
19.     public void setId(int id) {  
20.         this.id = id;  
21.     }  
22.     public String getMsg() {  
23.         return msg;  
24.     }  
25.     public void setMsg(String msg) {  
26.         this.msg = msg;  
27.     }  
28.       
29.       
30. }  

[java]  view plain copy print ?

1. package com.demo.dao.impl;  
2.   
3. import javax.annotation.Resource;  
4. import org.hibernate.Session;  
5. import org.hibernate.SessionFactory;  
6. import org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean;  
7. import org.springframework.stereotype.Component;  
8. import com.demo.dao.UserDAO;  
9. import com.demo.model.User;  
10.   
11. @Component("u")  
12. public class UserDAOImpl implements UserDAO {  
13.     private SessionFactory sessionFactory;  
14.     public SessionFactory getSessionFactory() {  
15.         return sessionFactory;  
16.     }  
17.     @Resource  
18.     public void setSessionFactory(SessionFactory sessionFactory) {  
19.         this.sessionFactory = sessionFactory;  
20.     }  
21.       
22.     @Override  
23.     public void save(User u) {  
24.         Session session = sessionFactory.getCurrentSession();  
25.         session.save(u);  
26.     }  
27.   
28. }  

[java]  view plain copy print ?

1. package com.demo.service;  
2.   
3. import javax.annotation.Resource;  
4.   
5. import org.springframework.beans.factory.annotation.Autowired;  
6. import org.springframework.beans.factory.annotation.Qualifier;  
7. import org.springframework.stereotype.Component;  
8. import org.springframework.transaction.annotation.Transactional;  
9.   
10. import com.demo.dao.LogDAO;  
11. import com.demo.dao.UserDAO;  
12. import com.demo.dao.impl.UserDAOImpl;  
13. import com.demo.model.Log;  
14. import com.demo.model.User;  
15. // 面向接口或者抽象编程,需要用谁直接在service 里面new谁 实现DAO接口即可  
16. //面向抽象编程就是 灵活  
17.   
18. @Component("userService")  
19. public class UserService {  
20.     private UserDAO userDAO;  
21.     private LogDAO logDAO;  
22.       
23.       
24.     public LogDAO getLogDAO() {  
25.         return logDAO;  
26.     }  
27.     @Resource  
28.     public void setLogDAO(LogDAO logDAO) {  
29.         this.logDAO = logDAO;  
30.     }  
31.   
32.     public void init() {  
33.         System.out.println("init");  
34.     }  
35.       
36.     public UserDAO getUserDAO() {  
37.         return userDAO;  
38.     }  
39.       
40.     @Resource(name="u") //常用  
41.     public void setUserDAO(UserDAO userDAO) {  
42.         this.userDAO = userDAO;  
43.     }  
44.       
45.     @Transactional //运行时异常会回滚  
46.     public void add(User u) {  
47.         this.userDAO.save(u);  
48.         Log log = new Log();  
49.         log.setMsg("a log saved");  
50.         this.logDAO.save(log);  
51.     }  
52.       
53.     public void destroy() {  
54.         System.out.println("destroy");  
55.     }  
56. }  

propagation  transaction 的产生过程

[java]  view plain copy print ?

1. @Transactional(propagation=Propagation.REQUIRED) //transaction运行时异常会回滚   
2.     //propagation=Propagation.REQUIRED 就是在当前的环境里面如果已经有transaction了就用原来的，没有就创建新的（重要）  

用xml的方式配置Transaction (大多数情况下用xml)

[html]  view plain copy print ?

1. <!-- 以下是xml 的方式完成声明式的事物 -->    
2.       <aop:config>  
3.         <aop:pointcut id="bussinessService" expression="execution(public * com.demo.service..*.*(..))"/>  
4.         <aop:advisor advice-ref="txAdvice" pointcut-ref="bussinessService"/>  
5.       </aop:config>  
6.       
7.         <tx:advice id="txAdvice" transaction-manager="txManager">  
8.         <tx:attributes>  
9.             <tx:method name="getUser*" read-only="true"/>  
10.             <tx:method name="add*" propagation="REQUIRED"/>  
11.         </tx:attributes>  
12.         </tx:advice>  

[html]  view plain copy print ?

1. 扫描model此包下面的实体类  
2.   
3. <property name="packagesToScan">  
4.           <list>  
5.             <value>com.demo.model</value>  
6.           </list>  
7.         </property>  

a)       HibernateTemplate、HibernateCallback、HibernateDaoSupport（不重要）介绍

                       i.             设计模式：TemplateMethod

                     ii.             Callback：回调/钩子函数

                   iii.             第一种：（建议）

1.       在spring中初始化HibernateTemplate，注入sessionFactory

2.       DAO里注入HibernateTemplate

3.       save写getHibernateTemplate.save();

                   iv.             第二种：

1.       从HibernateDaoSupport继承

2.       必须写在xml文件中，无法使用Annotation，因为set方法在父类中，而且是final的

b)       spring整合hibernate的时候使用packagesToScan属性，可以让spring自动扫描对应包下面的实体类

HibernateTemplate  （模板）

[html]  view plain copy print ?

1. <bean id="sesssionFactory" class="org.springframework.orm.hibernate3.HibernateTemplate">  
2.             <property name="sessionFactory" ref="sessionFactory"></property>  
3.         </bean>  

[java]  view plain copy print ?

1. package com.demo.dao.impl;  
2.   
3. import javax.annotation.Resource;  
4. import org.springframework.orm.hibernate3.HibernateTemplate;  
5. import org.springframework.stereotype.Component;  
6. import com.demo.dao.UserDAO;  
7. import com.demo.model.User;  
8.   
9. @Component("u")  
10. public class UserDAOImpl implements UserDAO {  
11.       
12.     private HibernateTemplate hibernateTemplate;  
13.     public HibernateTemplate getHibernateTemplate() {  
14.         return hibernateTemplate;  
15.     }  
16.     @Resource  
17.     public void setHibernateTemplate(HibernateTemplate hibernateTemplate) {  
18.         this.hibernateTemplate = hibernateTemplate;  
19.     }  
20.   
21.     @Override  
22.     public void save(User u) {  
23.         hibernateTemplate.save(u);  
24.     }  
25.   
26. }  

[java]  view plain copy print ?

1. <! -- <pre name="code" class="java">HibernateDaoSupport  三种方 不重要  

-->

package com.demo.dao.impl;import javax.annotation.Resource;import org.hibernate.SessionFactory;import org.springframework.orm.hibernate3.HibernateTemplate;import org.springframework.orm.hibernate3.support.HibernateDaoSupport;import org.springframework.stereotype.Component;/*@Componentpublic class SupportDAO {public HibernateTemplate hibernateTemplate;public HibernateTemplate getHibernateTemplate() {return hibernateTemplate;}@Resourcepublic void setHibernateTemplate(HibernateTemplate hibernateTemplate) {this.hibernateTemplate = hibernateTemplate;}}*//*@Componentpublic class SupportDAO extends HibernateDaoSupport{@Resource(name="hibernateTemplate")public void setSupporHibernateTemplate(HibernateTemplate hibernateTemplate) {super.setHibernateTemplate(hibernateTemplate);}}*/@Componentpublic class SupportDAO extends HibernateDaoSupport{@Resource(name="sessionFactory")public void setSupportSessionFactory(SessionFactory sessionFactory) {super.setSessionFactory(sessionFactory);}}————————————————————————————————————————————package com.demo.dao.impl;

import javax.annotation.Resource;
import org.springframework.orm.hibernate3.HibernateTemplate;
import org.springframework.stereotype.Component;
import com.demo.dao.UserDAO;
import com.demo.model.User;

@Component("u")
public class UserDAOImpl extends SupportDAO implements UserDAO {
    
    @Override
    public void save(User u) {
        super.getHibernateTemplate().save(u);
    }

}