Spring AOP学习笔记
Spring提供了一站式解决方案:
1) Spring Core spring的核心功能: IOC容器, 解决对象创建及依赖关系
2) Spring Web Spring对web模块的支持。
-à 可以与struts整合,让struts的action创建交给spring
-à spring mvc模式
3) Spring DAO Spring 对jdbc操作的支持 【JdbcTemplate模板工具类】
4) Spring ORM spring对orm的支持:
à 既可以与hibernate整合,【session】
à 也可以使用spring的对hibernate操作的封装
5)Spring AOP 切面编程
6)SpringEE spring 对javaEE其他模块的支持
目标:
1) 代理模式
静态代理
动态代理
Cglib代理
2)手动实现AOP编程 【代理模式】
3)AOP编程
* 注解方式实现
* XMl配置方式实现
4) Spring DAO
Spring对jdbc操作的支持
1. 代理模式
1.1 概述
代理(Proxy)是一种设计模式, 提供了对目标对象另外的访问方式;即通过代理访问目标对象。 这样好处: 可以在目标对象实现的基础上,增强额外的功能操作。(扩展目标对象的功能)。
举例:明星(邓紫棋)ß---经纪人<-------用户
目标 (代理)
代理模式的关键点: 代理对象与目标对象。
1.2 静态代理
静态代理,
1) 代理对象,要实现与目标对象一样的接口;
2) 举例:
保存用户(模拟)
Dao , 直接保存
DaoProxy, 给保存方法添加事务处理
总结静态代理:
1)可以做到在不修改目标对象的功能前提下,对目标对象功能扩展。
2)缺点:
--》 因为代理对象,需要与目标对象实现一样的接口。所以会有很多代理类,类太多。
--》 一旦接口增加方法,目标对象与代理对象都要维护。
解决:
代理工厂? 可以使用动态代理。
1.3 动态代理
动态代理,
1)代理对象,不需要实现接口;
2)代理对象的生成,是利用JDKAPI, 动态的在内存中构建代理对象(需要我们指定创建 代理对象/目标对象 实现的接口的类型;);
3) 动态代理, JDK代理, 接口代理;
JDK中生成代理对象的API:
|-- Proxy
static Object newProxyInstance(
ClassLoader loader, 指定当前目标对象使用类加载器
Class<?>[] interfaces, 目标对象实现的接口的类型
InvocationHandler h 事件处理器
)
动态代理总结:
代理对象不需要实现接口,但是目标对象一定要实现接口;否则不能用动态代理!
(class $Proxy0 implements IuserDao)
思考:
有一个目标对象,想要功能扩展,但目标对象没有实现接口,怎样功能扩展?
Class UserDao{}
// 子类的方式
Class subclass extends UserDao{}
以子类的方式实现(cglib代理)
1.4 Cglib代理
Cglib代理,也叫做子类代理。在内存中构建一个子类对象从而实现对目标对象功能的扩展。
l JDK的动态代理有一个限制,就是使用动态代理的对象必须实现一个或多个接口。如果想代理没有实现接口的类,就可以使用CGLIB实现。
l CGLIB是一个强大的高性能的代码生成包,它可以在运行期扩展Java类与实现Java接口。它广泛的被许多AOP的框架使用,例如Spring AOP和dynaop,为他们提供方法的interception(拦截)。
l CGLIB包的底层是通过使用一个小而快的字节码处理框架ASM,来转换字节码并生成新的类。不鼓励直接使用ASM,因为它要求你必须对JVM内部结构包括class文件的格式和指令集都很熟悉。
Cglib子类代理:
1) 需要引入cglib – jar文件, 但是spring的核心包中已经包括了cglib功能,所以直接引入spring-core-3.2.5.jar即可。
2)引入功能包后,就可以在内存中动态构建子类
3)代理的类不能为final, 否则报错。
4) 目标对象的方法如果为final/static, 那么就不会被拦截,即不会执行目标对象额外的业务方法。
在Spring的AOP编程中,
如果加入容器的目标对象有实现接口,用JDK代理;
如果目标对象没有实现接口,用Cglib代理;
2. 手动实现AOP编程
AOP 面向切面的编程,
AOP可以实现“业务代码”与“关注点代码”分离
分析总结:
关注点代码,就是指重复执行的代码。
业务代码与关注点代码分离,好处?
--à 关注点代码写一次即可;
-à开发者只需要关注核心业务;
-à运行时期,执行核心业务代码时候动态植入关注点代码; 【代理】
如何分离?
过程式/对象式/代理模式分离
3. AOP编程
3.1 概述:
Aop, aspect object programming 面向切面编程
功能: 让关注点代码与业务代码分离!
关注点,
重复代码就叫做关注点;
切面,
关注点形成的类,就叫切面类!切面类一般用于,日志、安全、权限方面使用。
面向切面编程,就是指 对很多功能都有的重复的代码抽取,再在运行的时候网业务方法上动态植入“切面类代码”。切面中的方法叫通知。
切入点,(相当于条件)
执行目标对象方法,动态植入切面代码。
可以通过切入点表达式,指定拦截哪些类的哪些方法; 给指定的类在运行的时候植入切面类代码。
![](https://images2018.cnblogs.com/blog/430354/201804/430354-20180428102425255-1394588503.png)
3.2 注解方式实现AOP编程
步骤:
1) 先引入aop相关jar文件 (aspectj aop优秀组件)
spring-aop-3.2.5.RELEASE.jar 【spring3.2源码】
aopalliance.jar 【spring2.5源码/lib/aopalliance】
aspectjweaver.jar 【spring2.5源码/lib/aspectj】或【aspectj-1.8.2\lib】
aspectjrt.jar 【spring2.5源码/lib/aspectj】或【aspectj-1.8.2\lib】
注意: 用到spring2.5版本的jar文件,如果用jdk1.7可能会有问题。
需要升级aspectj组件,即使用aspectj-1.8.2版本中提供jar文件提供。
2) bean.xml中引入aop名称空间
3) 开启aop注解
4) 使用注解
@Aspect 指定一个类为切面类
@Pointcut("execution(* cn.itcast.e_aop_anno.*.*(..))") 指定切入点表达式 (相当于条件)
@Before("pointCut_()") 前置通知: 目标方法之前执行
@After("pointCut_()") 后置通知:目标方法之后执行(始终执行)
@AfterReturning("pointCut_()") 返回后通知: 执行方法结束前执行(异常不执行)
@AfterThrowing("pointCut_()") 异常通知: 出现异常时候执行
@Around("pointCut_()") 环绕通知: 环绕目标方法执行
3.3 XML方式实现AOP编程
Xml实现aop编程:
1) 引入jar文件 【aop 相关jar, 4个】
2) 引入aop名称空间
3)aop 配置
* 配置切面类 (重复执行代码形成的类)
* aop配置
拦截哪些方法 / 拦截到方法后应用通知代码
3.4 切入点表达式
切入点表达式,
可以对指定的“方法”进行拦截; 从而给指定的方法所在的类生层代理对象。
![](https://images2018.cnblogs.com/blog/430354/201804/430354-20180428102530740-273106871.png)
![](https://images2018.cnblogs.com/blog/430354/201804/430354-20180428102759491-1207674443.jpg)
4. Spring对jdbc支持
使用步骤:
1)引入jar文件
spring-jdbc-3.2.5.RELEASE.jar
spring-tx-3.2.5.RELEASE.jar
2) 优化
< aop:aspect>和< aop:advisor>的区别
- < aop:aspect>:定义AOP通知器、大多用于日志,缓存
- < aop:advisor>:定义切面、大多用于事务管理。
比如,下面是一个对Service包上所有方法的切面配置
<aop:config>
<aop:pointcut id="serviceOperation"
expression="execution(* *..service*..*(..))"/>
<aop:advisor pointcut-ref="serviceOperation"
advice-ref="txAdvice"/>
</aop:config>
表达式所处位置如上pointcut的位置。
配置这个为了更好控制切面上的事务,下面是一个事物配置的简单例子:
<tx:advice id="txAdvice" transaction-manager="transactionManager">
<tx:attributes>
<tx:method name="delete*" rollback-for="Exception"/>
<tx:method name="save*" rollback-for="Exception"/>
<tx:method name="update*" rollback-for="Exception"/>
<tx:method name="*" read-only="true" rollback-for="Exception"/>
</tx:attributes>
</tx:advice>
通过切面、通知的配置,就为所有的delete/save/update开头的方法添加上了一致性事务,对其他方法添加上了只读事务。
表示service包下的所有方法为为事务管理。
spring与hibernate整合
1、注入SessionFactory方式
1、在配置文件中,引入sessionFactory。
<!--
引入sessionFactory 方法一
-->
<bean id="sessionFactory1" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
<property name="configLocation">
<value>classpath:hibernate.cfg.xml</value>
</property>
</bean>
<!--
引入sessionFactory 方法二
-->
<bean id="sessionFactory2" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
<property name="dataSource" ref="dataSource" />
<!--
映射文件所在的路径
-->
<property name="mappingDirectoryLocations">
<list>
<!--
spring容器会去该包及子包下搜索所有的映射文件
-->
<value>com/itheima12/spring/hibernate/transaction/domain</value>
</list>
</property>
<property name="hibernateProperties">
<props>
<prop key="hibernate.dialect">org.hibernate.dialect.MySQL5InnoDBDialect</prop>
<prop key="hibernate.show_sql">true</prop>
<prop key="hibernate.hbm2ddl.auto">update</prop>
</props>
</property>
</bean>
2、继承HibernateDaoSupport
public class PersonDaoImpl extends HibernateDaoSupport implements PersonDao{
public void savePerson(Person person) {
// TODO Auto-generated method stub
this.getHibernateTemplate().save(person);
}
}
2、注入HibernateTemplate方式
配置文件如下所示:
<bean id="hibernateTemplate" class="org.springframework.orm.hibernate3.HibernateTemplate">
<property name="sessionFactory" ref="sessionFactory"></property>
</bean>
DAO编码如下所示:
private HibernateTemplate hibernateTemplate;
// 定义一个Logger,便于它及其子类计入日志用
protected Logger logger = Logger.getLogger(this.getClass());
public HibernateTemplate getHibernateTemplate() {
return hibernateTemplate;
}
public void setHibernateTemplate(HibernateTemplate hibernateTemplate) {
this.hibernateTemplate = hibernateTemplate;
}
@Override
public <T> void saveEntity(T entity) {
// TODO Auto-generated method stub
this.hibernateTemplate.saveOrUpdate(entity);
}
3、注入jdbcTemplate方式
这种配置是使用Spring对JDBC的封装,而非Hibernate。即不加载Hibernate容器,直接使用Spring对JDBC的封装来操作数据库
第一种配置:给DAO类注入数据源dataSource
配置如下:
Xml代码
- <bean id="userManageImpl" class="com.nos.business.springJDBC.impl.UserManageImpl">
- <property name="dataSource" ref="dataSource" />
- </bean>
DAO编码如下所示:
Java代码
- public class UserManageImpl implements IUserManage{
- private JdbcTemplate jdbcTemplate;
- @Resource(name="dataSource")
- public void setDataSource(DataSource dataSource){
- this.jdbcTemplate = new JdbcTemplate(dataSource);
- }
- @Override
- public void add(UserVo vo)
- {
- jdbcTemplate.update("insert into user_info(name,sex) values(?,?)", new Object[]{vo.getName(), vo.getSex()});
- }
- }
第二种配置:直接给Dao类注入JdbcTemplate
配置如下:
Xml代码
- <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
- <property name="dataSource" ref="dataSource" />
- </bean>
DAO编码如下所示:
Java代码
- public class UserManageImpl2 implements IUserManage{
- @Resource
- private JdbcTemplate jdbcTemplate;
- @Override
- public void add(UserVo vo)
- {
- jdbcTemplate.update("insert into user_info(name,sex) values(?,?)", new Object[]{vo.getName(), vo.getSex()});
- }
- }
spring的声明式事务处理:
(让程序员不再关注事务)
声明:由程序告诉spring容器,什么样的目标方法采用什么样的事务策略
事务处理:是由spring容器来完成的
crud操作:程序员做的事情
1、XML方式实现声明式事务处理
以下是声明式事务处理的例子:
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
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
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">
<!--
引入properties配置文件
-->
<bean
class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
<property name="locations">
<value>classpath:jdbc.properties</value>
</property>
</bean>
<bean id="dataSource" destroy-method="close"
class="org.apache.commons.dbcp.BasicDataSource">
<property name="driverClassName" value="${jdbc.driverClassName}" />
<property name="url" value="${jdbc.url}" />
<property name="username" value="${jdbc.username}" />
<property name="password" value="${jdbc.password}" />
</bean>
<!--
引入sessionFactory
-->
<bean id="sessionFactory1" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
<property name="configLocation">
<value>classpath:hibernate.cfg.xml</value>
</property>
</bean>
<bean id="sessionFactory2" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
<property name="dataSource" ref="dataSource" />
<!--
映射文件所在的路径
-->
<property name="mappingDirectoryLocations">
<list>
<!--
spring容器会去该包及子包下搜索所有的映射文件
-->
<value>com/itheima12/spring/hibernate/transaction/domain</value>
</list>
</property>
<property name="hibernateProperties">
<props>
<prop key="hibernate.dialect">org.hibernate.dialect.MySQL5InnoDBDialect</prop>
<prop key="hibernate.show_sql">true</prop>
<prop key="hibernate.hbm2ddl.auto">update</prop>
</props>
</property>
</bean>
<bean id="personDao" class="com.itheima12.spring.hibernate.transaction.dao.impl.PersonDaoImpl">
<property name="sessionFactory">
<ref bean="sessionFactory2"/>
</property>
</bean>
<bean id="personService" class="com.itheima12.spring.hibernate.transaction.service.impl.PersonServiceImpl">
<property name="personDao">
<ref bean="personDao"/>
</property>
</bean>
<!--
事务管理器
-->
<bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
<property name="sessionFactory">
<ref bean="sessionFactory2"/>
</property>
</bean>
<!--
事务的声明
-->
<tx:advice transaction-manager="transactionManager" id="tx">
<tx:attributes>
<!--
name: 目标方法的范围
isolation 隔离机制
propagation 传播属性 解决事务的嵌套问题
read-only
true 只读事务
false 读写事务
-->
<tx:method name="save*" isolation="DEFAULT" propagation="REQUIRED"
read-only="false"/>
</tx:attributes>
</tx:advice>
<aop:config>
<aop:pointcut
expression="execution(* com.itheima12.spring.hibernate.transaction.service.impl.*.*(..))"
id="perform"/>
<aop:advisor advice-ref="tx" pointcut-ref="perform"/>
</aop:config>
</beans>
2、注解方式实现方式 实现声明式事务处理
使用注解实现Spring的声明式事务管理,更加简单!
步骤:
1) 必须引入Aop相关的jar文件
2) bean.xml中指定注解方式实现声明式事务管理以及应用的事务管理器类
3)在需要添加事务控制的地方,写上: @Transactional
@Transactional注解:
1)应用事务的注解
2)定义到方法上: 当前方法应用spring的声明式事务
3)定义到类上: 当前类的所有的方法都应用Spring声明式事务管理;
4)定义到父类上: 当执行父类的方法时候应用事务。
Bean.xm
<?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:p="http://www.springframework.org/schema/p"
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.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx.xsd">
<!-- 1. 数据源对象: C3P0连接池 -->
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
<property name="driverClass" value="com.mysql.jdbc.Driver"></property>
<property name="jdbcUrl" value="jdbc:mysql:///hib_demo"></property>
<property name="user" value="root"></property>
<property name="password" value="root"></property>
<property name="initialPoolSize" value="3"></property>
<property name="maxPoolSize" value="10"></property>
<property name="maxStatements" value="100"></property>
<property name="acquireIncrement" value="2"></property>
</bean>
<!-- 2. JdbcTemplate工具类实例 -->
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
<property name="dataSource" ref="dataSource"></property>
</bean>
<!-- 事务管理器类 -->
<bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="dataSource"></property>
</bean>
<!-- 开启注解扫描 -->
<context:component-scan base-package="cn.itcast.b_anno"></context:component-scan>
<!-- 注解方式实现事务: 指定注解方式实现事务 -->
<tx:annotation-driven transaction-manager="txManager"/>
</beans>
DeptService
@Service
public class DeptService {
@Resource
private DeptDao deptDao;
/*
* 事务控制?
*/
@Transactional
public void save(Dept dept){
deptDao.save(dept);
int i = 1/0;
deptDao.save(dept);
}
}
事务属性
@Transactional(
readOnly = false, // 读写事务
timeout = -1, // 事务的超时时间不限制
noRollbackFor = ArithmeticException.class, // 遇到数学异常不回滚
isolation = Isolation.DEFAULT, // 事务的隔离级别,数据库的默认
propagation = Propagation.REQUIRED // 事务的传播行为
)
public void save(Dept dept){
deptDao.save(dept);
int i = 1/0;
deptDao.save(dept);
}
Spring HibernateTransactionManager事物管理类
我们在Spring里通常把事务交给HibernateTransactionManager来处理,通过Aop配置事务,把事务交给该类之后就会由该类来帮我们管理和提供事务。
<context:annotation- config/>的作用:
使用<context:annotation- config/>隐式地向 Spring容器注册AutowiredAnnotationBeanPostProcessor、RequiredAnnotationBeanPostProcessor、CommonAnnotationBeanPostProcessor以及PersistenceAnnotationBeanPostProcessor这4个BeanPostProcessor。
因为: 使用@Autowired注解,必须事先在Spring容器中声明AutowiredAnnotationBeanPostProcessor的Bean:
<bean class="org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor "/>