Spring框架2
AOP的概述
AOP 的底层实现
Spring 的AOP
使用AspectJ实现AOP
Spring JdbcTemplate 使用
复习
Spring的IOC.Spring就是一个大的工厂,通过工厂对Bean进行管理.
* Spring的概述:
* Spring的环境搭建:
* Spring中的IOC:
* IOC:控制反转.将对象的创建权交给Spring管理.
* DI:依赖注入.在由Spring创建的对象的时候,将对象依赖的对象注入进来.
* IOC的Bean装配(XML):
* 定义类:
* <bean id=”标识”class=”类的全路径”>
* 其他的属性:
* id和name:
* id:满足XML id约束语法,里面不能出现特殊的字符.
* name:可以出现特殊的字符.
***** 如果配置<bean>标签的时候,如果只配置了name,就可以将这个name的值作为id.
* scope:类的作用范围.
* Bean的生命周期:
* init-method:
* destroy-method:
* Bean的完整生命周期:
*后处理Bean.增强
* 注入属性:
* <property name=”” value=””>
* <property name=”” ref=””>
* IOC的Bean装配(注解):
* 定义类:
* 注入属性:
* Spring框架与web整合.
* Spring整合JUnit单元测试.
Spring的AOP.JdbcTemplate.
1.2 AOP的概述:
1.2.1 什么是AOP:
AOP Aspect Oriented Programing 面向切面编程
AOP采取横向抽取机制，取代了传统纵向继承体系重复性代码（性能监视、事务管理、安全检查、缓存）
Spring AOP使用纯Java实现，不需要专门的编译过程和类加载器，在运行期通过代理方式向目标类织入增强代码
AspecJ是一个基于Java语言的AOP框架，Spring2.0开始，Spring AOP引入对Aspect的支持，AspectJ扩展了Java语言，提供了一个专门的编译器，在编译时提供横向代码的织入
1.2.2 AOP底层原理;
就是代理机制:
* 动态代理:(JDK中使用)
* JDK的动态代理,对实现了接口的类生成代理.（条件）
1.2.3 Spring的AOP代理:
JDK动态代理:对实现了接口的类生成代理
CGLib代理机制:对类生成代理
1.2.4 AOP的相关术语:
Joinpoint(连接点):所谓连接点是指那些被拦截到的点。在spring中,这些点指的是方法,因为spring只支持方法类型的连接点.
Pointcut(切入点):所谓切入点是指我们要对哪些Joinpoint进行拦截的定义.
Advice(通知/增强):所谓通知是指拦截到Joinpoint之后所要做的事情就是通知.通知分为前置通知,后置通知,异常通知,最终通知,环绕通知(切面要完成的功能)
Introduction(引介):引介是一种特殊的通知在不修改类代码的前提下, Introduction可以在运行期为类动态地添加一些方法或Field.
Target(目标对象):代理的目标对象
Weaving(织入):是指把增强应用到目标对象来创建新的代理对象的过程.
spring采用动态代理织入，而AspectJ采用编译期织入和类装在期织入
Proxy（代理）:一个类被AOP织入增强后，就产生一个结果代理类
Aspect(切面): 是切入点和通知（引介）的结合
1.3 AOP的底层实现
1.3.1 JDK动态代理:
public class JDKProxy implements InvocationHandler{//这个类就本身相当于InvocationHandler
private UserDao userDao;//获取目标对象
public JDKProxy(UserDao userDao) {
super();
this.userDao = userDao;//构造的时候传入目标对象
}
public UserDao createProxy() {//对接口生成代理
UserDao proxy = (UserDao)Proxy.newProxyInstance(userDao.getClass()
.getClassLoader(),userDao.getClass().getInterfaces(), this);//生成代理对象（类加载器，实现接口，InvocationHandler）
return proxy;
}
// 调用目标对象的任何一个方法 都相当于调用invoke();
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
if("add".equals(method.getName())){
// 记录日志:
System.out.println("日志记录=================");
Object result = method.invoke(userDao, args);//执行add（添加用户）的方法
return result;
}
return method.invoke(userDao, args);//其他方法
}
}
@Test
public void demo2(){
// 被代理对象
UserDao userDao = new UserDaoImpl();
// 创建代理对象的时候传入被代理对象.
UserDao proxy = new JDKProxy(userDao).createProxy();//生成代理
proxy.add();//调用方法
proxy.update();
}
1.3.2 CGLIB动态代理:
CGLIB(Code GenerationLibrary)是一个开源项目！是一个强大的，高性能，高质量的Code生成类库，它可以在运行期扩展Java类与实现Java接口。Hibernate支持它来实现PO(Persistent Object 持久化对象)字节码的动态生成
CGlib采用非常底层字节码技术，可以为一个类创建子类，解决无接口代理问题
Hibernate生成持久化类的javassist.
CGLIB生成代理机制:其实生成了一个真实对象的子类.（普通类就可以实现代理，继承的方式）
下载cglib的jar包.
* 现在做cglib的开发,可以不用直接引入cglib的包.已经在spring的核心中集成cglib.
public class CGLibProxy implements MethodInterceptor{
private ProductDao productDao;//被代理对象
public CGLibProxy(ProductDao productDao) {
super();
this.productDao =productDao;//通过构造传入被代理对象
}
public ProductDao createProxy(){
// 使用CGLIB生成代理:
// 1.创建核心类:
Enhancer enhancer = newEnhancer();
// 2.为其设置父类:
enhancer.setSuperclass(productDao.getClass());//机制为继承的方式，它得知道对谁生成动态代理，productDao
// 3.设置回调:（相当于动态代理的invoke）
enhancer.setCallback(this);
// 4.创建代理:
return (ProductDao)enhancer.create();
}
public Object intercept(Object proxy, Method method, Object[] args,
MethodProxy methodProxy) throws Throwable {
if("add".equals(method.getName())){
System.out.println("日志记录==============");
Object obj = methodProxy.invokeSuper(proxy, args);//执行父类（代理对象proxy：调子类的方法相当于调用父类的ProductDao）
return obj;
}
return methodProxy.invokeSuper(proxy, args);
}
}
@Test
public void demo2(){
ProductDao productDao = new ProductDao();
ProductDao proxy = new CGLibProxy(productDao).createProxy();
proxy.add();
proxy.update();
}
/**
* @param obj CGlib根据指定父类生成的代理对象
* @param method 拦截的方法
* @param args 拦截方法的参数数组
* @param proxy 方法的代理对象，用于执行父类的方法
* @return
*/
public Object intercept(Object obj, Method method, Object[] args,
MethodProxy proxy) throws Throwable {
... ...
}
结论:Spring框架,如果类实现了接口,就使用JDK的动态代理生成代理对象,如果这个类没有实现任何接口,使用CGLIB生成代理对象.
代理知识总结：
Spring在运行期，生成动态代理对象，不需要特殊的编译器
1.若目标对象实现了若干接口，spring使用JDK的java.lang.reflect.Proxy类代理。
2.若目标对象没有实现任何接口，spring使用CGLIB库生成目标对象的子类。
1.4 Spring中的AOP
1.4.1 Spring的传统AOP :
AOP:不是由Spring定义.AOP联盟的组织定义.
Spring中的通知:(增强代码)
前置通知org.springframework.aop.MethodBeforeAdvice
* 在目标方法执行前实施增强
后置通知org.springframework.aop.AfterReturningAdvice
* 在目标方法执行后实施增强
环绕通知org.aopalliance.intercept.MethodInterceptor
* 在目标方法执行前后实施增强
异常抛出通知 org.springframework.aop.ThrowsAdvice
* 在方法抛出异常后实施增强
引介通知org.springframework.aop.IntroductionInterceptor
* 在目标类中添加一些新的方法和属性
1.4.2 Spring中的切面类型:
Advisor : Spring中传统切面.
* Advisor:都是有一个切点和一个通知组合.
* Aspect:多个切点和多个通知组合.
Advisor : 代表一般切面，Advice本身就是一个切面，对目标类所有方法进行拦截( 即：不带有切点的切面.针对所有方法进行拦截)
PointcutAdvisor : 代表具有切点的切面，可以指定拦截目标类哪些方法(带有切点的切面,针对某个方法进行拦截)
IntroductionAdvisor : 代表引介切面，针对引介通知而使用切面（不要求掌握）
1.4.3 Spring的AOP的开发:
针对所有方法的增强:(不带有切点的切面)Advisor
第一步:导入相应jar包.
* spring-aop-3.2.0.RELEASE.jar
* com.springsource.org.aopalliance-1.0.0.jar（AOP）
第二步:编写被代理对象:
* CustomerDao接口
* CustoemrDaoImpl实现类
第三步:编写增强的代码:
public class MyBeforeAdvice implements MethodBeforeAdvice{
/**
* method:执行的方法
* args:参数
* target:目标对象
*/
public void before(Methodmethod, Object[] args, Object target)
throws Throwable {//需要导源代码
System.out.println("前置增强...");
}
}
第四步:生成代理:(配置生成代理:)
* 生成代理Spring基于ProxyFactoryBean类.底层自动选择使用JDK的动态代理还是CGLIB的代理.
* 属性:
target : 代理的目标对象
proxyInterfaces : 代理要实现的接口
如果多个接口可以使用以下格式赋值
<list>
<value></value>
....
</list>
proxyTargetClass : 是否对类代理而不是接口，设置为true时，使用CGLib代理（与proxyInterfaces互斥 ）
interceptorNames : 需要织入目标的Advice
singleton : 返回代理是否为单实例，默认为单例
optimize : 当设置为true时，强制使用CGLib
beans xmlns="http://www.springframework.org/schema/beans"
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.xsd">
<!-- 定义目标对象 -->
<bean id="customerDao"class="cn.itcast.spring3.demo3.CustomerDaoImpl"></bean>（customerDao：接口；CustomerDaoImpl实现类）
<!-- 定义增强 -->
<bean id="beforeAdvice"class="cn.itcast.spring3.demo3.MyBeforeAdvice"></bean>
<!-- Spring支持配置生成代理:（代理对象） -->
<bean id="customerDaoProxy"class="org.springframework.aop.framework.ProxyFactoryBean">
<!-- 设置目标对象 -->
<property name="target" ref="customerDao"/>
<!-- 设置实现的接口 ,value中写接口的全路径 -->
<property name="proxyInterfaces" value="cn.itcast.spring3.demo3.CustomerDao"/>
<!-- 需要使用value:要的名称， 需要织入目标的Advice-->
<property name="interceptorNames" value="beforeAdvice"/>
</bean>
***** 注入的时候要注入代理对象:
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class SpringTest3 {
@Autowired
// @Qualifier("customerDao")// 注入是真实的对象
@Qualifier("customerDaoProxy")//,必须注入代理对象.
private CustomerDao customerDao;
@Test
public void demo1(){
customerDao.add();
customerDao.update();
customerDao.delete();
customerDao.find();
}
}
使用普通Advice作为切面，将对目标类所有方法进行拦截，不够灵活，在实际开发中常采用 带有切点的切面
有一个类就要配置一段，不实用
带有切点的切面:(针对目标对象的某些方法进行增强)PointcutAdvisor
PointcutAdvisor 接口:（常用PointcutAdvisor 实现类）
DefaultPointcutAdvisor 最常用的切面类型，它可以通过任意Pointcut和Advice组合定义切面
RegexpMethodPointcutAdvisor 构造正则表达式切点切面
第一步:创建被代理对象.
* OrderDao （目标对象）
第二步:编写增强的类:
public class MyAroundAdvice implements MethodInterceptor{//环绕增强（要用AOP联盟的，cglib中也有）
public Objectinvoke(MethodInvocation methodInvocation) throws Throwable {
System.out.println("环绕前增强...");
Object result = methodInvocation.proceed();// 执行目标对象的方法（return null：目标方法不执行）
System.out.println("环绕后增强...");
return result;
}
}
第三步:生成代理:（通过配置的方式）
<!-- 带有切点的切面 -->
<!-- 定义目标对象 -->
<bean id="orderDao"class="cn.itcast.spring3.demo4.OrderDao"></bean>
<!-- 定义增强-->
<bean id="aroundAdvice" class="cn.itcast.spring3.demo4.MyAroundAdvice"></bean>
<!-- 定义切点切面: -->（定义某些方法增强）
<bean id="myPointcutAdvisor"class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">
<!-- 定义表达式,规定哪些方法执行拦截 -->（pattern：规则，定义一个；patterns定义多个）
<!-- . 任意字符 * 任意个 -->
<!-- <property name="pattern" value=".*"/> -->（所有增强）
<!-- <property name="pattern"value="cn\.itcast\.spring3\.demo4\.OrderDao\.add.*"/> -->（\：转义）（只有add增强，详细的写法）
<!-- <property name="pattern" value=".*add.*"></property> -->（只有add增强）
<property name="patterns"value=".*add.*,.*find.*"></property>
<!-- 应用增强 -->
<property name="advice" ref="aroundAdvice"/>
</bean>
<!-- 定义生成代理对象 -->
<bean id="orderDaoProxy"class="org.springframework.aop.framework.ProxyFactoryBean">
<!-- 配置目标 -->
<property name="target" ref="orderDao"></property>
<!-- 针对类的代理 -->
<property name="proxyTargetClass" value="true"></property>
<!-- 在目标上应用增强 -->
<property name="interceptorNames"value="myPointcutAdvisor"></property>
</bean>
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class SpringTest4 {
@Autowired
@Qualifier("orderDaoProxy")
private OrderDao orderDao;
@Test
public void demo1(){
orderDao.add();
orderDao.delete();
orderDao.update();
orderDao.find();
}
}
上面方法：先有目标对象:被代理对象（UserDao userDao = new UserDaoImpl();）
然后创建代理对象的时候传入被代理对象.（UserDao proxy = new JDKProxy(userDao).createProxy();或者配置文件中）
1.4.4 自动代理:
前面的案例中，每个代理都是通过ProxyFactoryBean织入切面代理，在实际开发中，非常多的Bean每个都配置ProxyFactoryBean开发维护量巨大
自动创建代理(*****基于后处理Bean.在Bean创建的过程中完成的增强.生成Bean就是代理.)（与上面机制不一样）
生成类就是代理对象
BeanNameAutoProxyCreator根据Bean名称创建代理
DefaultAdvisorAutoProxyCreator根据Advisor本身包含信息创建代理
*AnnotationAwareAspectJAutoProxyCreator 基于Bean中的AspectJ 注解进行自动代理
1，BeanNameAutoProxyCreator :按名称生成代理
<!-- 定义目标对象 -->
<bean id="customerDao" class="cn.itcast.spring3.demo3.CustomerDaoImpl"></bean>
<bean id="orderDao"class="cn.itcast.spring3.demo4.OrderDao"></bean>
<!-- 定义增强-->
<bean id="beforeAdvice"class="cn.itcast.spring3.demo3.MyBeforeAdvice"></bean>
<bean id="aroundAdvice" class="cn.itcast.spring3.demo4.MyAroundAdvice"></bean>
<!-- 自动代理:按名称的代理 基于后处理Bean,后处理Bean不需要配置ID-->（有框架自动调用）
<bean class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator">
<property name="beanNames" value="*Dao"/>
<property name="interceptorNames" value="beforeAdvice"/>
</bean>
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext2.xml")
public class SpringTest5 {
@Autowired
@Qualifier("orderDao")
private OrderDao orderDao;
@Autowired
@Qualifier("customerDao")
private CustomerDao customerDao;
@Test
public void demo1(){
orderDao.add();
orderDao.delete();
customerDao.update();
}
}
2，DefaultAdvisorAutoProxyCreator:根据切面中定义的信息生成代理
<!-- 定义目标对象 -->
<bean id="customerDao"class="cn.itcast.spring3.demo3.CustomerDaoImpl"></bean>
<bean id="orderDao"class="cn.itcast.spring3.demo4.OrderDao"></bean>
<!-- 定义增强-->
<bean id="beforeAdvice"class="cn.itcast.spring3.demo3.MyBeforeAdvice"></bean>
<bean id="aroundAdvice"class="cn.itcast.spring3.demo4.MyAroundAdvice"></bean>
<!-- 定义一个带有切点的切面 -->
<bean id="myPointcutAdvisor"class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">
<property name="pattern" value=".*add.*"/>
<property name="advice" ref="aroundAdvice"/>
</bean>
<!-- 自动生成代理 -->
<bean class="org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator"></bean>
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext3.xml")
public class SpringTest6 {
@Autowired
@Qualifier("orderDao")
private OrderDao orderDao;
@Autowired
@Qualifier("customerDao")
private CustomerDao customerDao;
@Test
public void demo1(){
orderDao.add();
orderDao.update();
orderDao.delete();
customerDao.add();
}
}
区分基于ProxyFattoryBean的代理与自动代理区别?
*****ProxyFactoryBean:先有被代理对象,将被代理对象传入到代理类中生成代理.
自动代理基于后处理Bean.在Bean的生成过程中,就产生了代理对象,把代理对象返回.生成Bean已经是代理对象.
1.5 Spring的AspectJ的AOP(*****)
AspectJ是一个面向切面的框架，它扩展了Java语言。AspectJ定义了AOP语法所以它有一个专门的编译器用来生成遵守Java字节编码规范的Class文件。
AspectJ是一个基于Java语言的AOP框架
Spring2.0以后新增了对AspectJ切点表达式支持
@AspectJ 是AspectJ1.5新增功能，通过JDK5注解技术，允许直接在Bean类中定义切面
新版本Spring框架，建议使用AspectJ方式来开发AOP
使用AspectJ 需要导入Spring AOP和 AspectJ相关jar包
spring-aop-3.2.0.RELEASE.jar
com.springsource.org.aopalliance-1.0.0.jar
spring-aspects-3.2.0.RELEASE.jar
com.springsource.org.aspectj.weaver-1.6.8.RELEASE.jar
AspectJ表达式:
* 语法:execution(表达式)
execution(<访问修饰符>?<返回类型><方法名>(<参数>)<异常>)
* execution(“* cn.itcast.spring3.demo1.dao.*(..)”) ---只检索当前包
* execution(“* cn.itcast.spring3.demo1.dao..*(..)”) ---检索dao包及当前包的子包.
* execution(* cn.itcast.dao.GenericDAO+.*(..)) ---检索GenericDAO及子类(匹配实现特定接口所有类方法
匹配所有类public方法 execution(public * *(..))
匹配指定包下所有类方法 execution(* cn.itcast.dao.*(..)) 不包含子包
execution(* cn.itcast.dao..*(..)) ..*表示包、子孙包下所有类
匹配指定类所有方法 execution(* cn.itcast.service.UserService.*(..))
匹配所有save开头的方法 execution(* save*(..))
AspectJ增强:
@Before 前置通知，相当于BeforeAdvice
@AfterReturning 后置通知，相当于AfterReturningAdvice
@Around 环绕通知，相当于MethodInterceptor
@AfterThrowing抛出通知，相当于ThrowAdvice
@After 最终final通知，不管是否异常，该通知都会执行
@DeclareParents 引介通知，相当于IntroductionInterceptor (不要求掌握)
1.5.1 基于注解:
第一步:引入相应jar包.
* aspectj依赖aop环境.
* spring-aspects-3.2.0.RELEASE.jar
* com.springsource.org.aspectj.weaver-1.6.8.RELEASE.jar
第二步:编写被增强的类:
* UserDao
第三步:使用AspectJ注解形式:
@Aspect//定义切面类
public class MyAspect {
@Before("execution(* cn.itcast.spring3.demo1.UserDao.add(..))")
public void before(){
System.out.println("前置增强....");
}
}
第四步:创建applicationContext.xml
* 引入aop的约束:
<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.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">
* <aop:aspectj-autoproxy /> --- 自动生成代理: 底层就是AnnotationAwareAspectJAutoProxyCreator
<aop:aspectj-autoproxy/>
<bean id="userDao" class="cn.itcast.spring3.demo1.UserDao"></bean>
<bean id="myAspect"class="cn.itcast.spring3.demo1.MyAspect"></bean>（定义切面）
五;测试：
@Aspect
public class MyAspect {}
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class SpringTest1 {
@Autowired
@Qualifier("userDao")
private UserDao userDao;
@Test
public void demo1(){
userDao.add();
userDao.delete();
userDao.update();
userDao.find();
}
}
AspectJ的通知类型:
@Before前置通知，相当于BeforeAdvice
* 就在方法之前执行.没有办法阻止目标方法执行的.
@AfterReturning后置通知，相当于AfterReturningAdvice
* 后置通知,获得方法返回值.
@Around环绕通知，相当于MethodInterceptor
* 在可以方法之前和之后来执行的,而且可以阻止目标方法的执行.
重点：如果不调用ProceedingJoinPoint的 proceed方法，那么目标方法就被拦截了
@AfterThrowing抛出通知，相当于ThrowAdvice
@After最终final通知，不管是否异常，该通知都会执行
@DeclareParents 引介通知，相当于IntroductionInterceptor (不要求掌握)
/**
* 切面类:就是切点与增强结合
* @author 姜涛
*
*/
@Aspect
public class MyAspect {
@Before("execution(* cn.itcast.spring3.demo1.UserDao.add(..))")
public void before(JoinPoint joinPoint){
System.out.println("前置增强...."+joinPoint);
}
@AfterReturning(value="execution(* cn.itcast.spring3.demo1.UserDao.update(..))",returning="returnVal")
public void afterReturin(Object returnVal){
System.out.println("后置增强....方法的返回值:"+returnVal);
}
@Around(value="MyAspect.myPointcut()")
public Object around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable{
System.out.println("环绕前增强....");
Object obj = proceedingJoinPoint.proceed();
System.out.println("环绕后增强....");
return obj;
}
@AfterThrowing(value="MyAspect.myPointcut()",throwing="e")//e与下一致
public void afterThrowing(Throwable e){
System.out.println("不好了 出异常了!!!"+e.getMessage());//显示异常信息
}
@After("MyAspect.myPointcut()")//都是针对find方法
public void after(){
System.out.println("最终通知...");
}
@Pointcut("execution(* cn.itcast.spring3.demo1.UserDao.find(..))")
private void myPointcut(){}//修饰属性和方法，方法名可任意取，没有实际意义
}
切点的定义:
在每个通知内定义切点，会造成工作量大，不易维护，对于重复的切点，可以使用@Poingcut进行定义
切点方法：private void 无参数方法，方法名为切点名
当通知多个切点时，可以使用|| 进行连接
@Pointcut("execution(*cn.itcast.spring3.demo1.UserDao.find(..))")
private void myPointcut(){}
面试:
* Advisor和Aspect的区别?
* Advisor:Spring传统意义上的切面:支持一个切点和一个通知的组合.
* Aspect:可以支持多个切点和多个通知的组合.
1.5.2 基于XML:
第一步:编写被增强的类:
* ProductDao
第二步:定义切面
第三步:配置applicationContext.xmll
前置通知:
* 代码:
public void before(){
System.out.println("前置通知...");
}
<!-- 定义被增强的类 -->
<bean id="productDao" class="cn.itcast.spring3.demo2.ProductDao"></bean>
<!-- 定义切面 -->
<bean id="myAspectXML" class="cn.itcast.spring3.demo2.MyAspectXML"></bean>
<!-- 定义aop配置 -->
<aop:config>
<!-- 定义切点:-->（定义哪些类哪些方法应用）
<aop:pointcut expression="execution(*cn.itcast.spring3.demo2.ProductDao.add(..))" id="mypointcut"/>
<aop:aspect ref="myAspectXML">（定义切面引用）
<!-- 前置通知 -->
<aop:beforemethod="before" pointcut-ref="mypointcut"/>（在哪些方法应用）
</aop:aspect>
</aop:config>
后置通知:
* 代码:
public void afterReturing(Object returnVal){
System.out.println("后置通知...返回值:"+returnVal);//可拿到返回值
}
* 配置:
<aop:config>
<!-- 定义切点:-->
<aop:pointcut expression="execution(*cn.itcast.spring3.demo2.ProductDao.add(..))"id="mypointcut"/>
<aop:aspect ref="myAspectXML">
<!-- 后置通知 -->
<aop:after-returningmethod="afterReturing" pointcut-ref="mypointcut"returning="returnVal"/>
</aop:aspect>
</aop:config>
环绕通知:
* 代码:
public Objectaround(ProceedingJoinPoint proceedingJoinPoint) throws Throwable{
System.out.println("环绕前增强....");
Object result = proceedingJoinPoint.proceed();
System.out.println("环绕后增强....");
return result;
}
* 配置:
<aop:config>
<!-- 定义切点:-->
<aop:pointcut expression="execution(*cn.itcast.spring3.demo2.ProductDao.add(..))"id="mypointcut"/>
<aop:aspect ref="myAspectXML">
<!-- 环绕通知 -->
<aop:around method="around"pointcut-ref="mypointcut"/>
</aop:aspect>
</aop:config>
异常通知:
* 代码;
public void afterThrowing(Throwable e){
System.out.println("异常通知..."+e.getMessage());
}
* 配置;
<aop:config>
<!-- 定义切点:-->
<aop:pointcut expression="execution(*cn.itcast.spring3.demo2.ProductDao.add(..))"id="mypointcut"/>
<aop:aspect ref="myAspectXML">
<!-- 异常通知 -->
<aop:after-throwingmethod="afterThrowing" pointcut-ref="mypointcut"throwing="e"/>
</aop:aspect>
</aop:config>
最终通知:
* 代码:
public void after(){
System.out.println("最终通知....");
}
* 配置:
<aop:config>
<!-- 定义切点:-->
<aop:pointcut expression="execution(*cn.itcast.spring3.demo2.ProductDao.add(..))"id="mypointcut"/>
<aop:aspect ref="myAspectXML">
<!-- 最终通知 -->
<aop:aftermethod="after" pointcut-ref="mypointcut"/>
</aop:aspect>
</aop:config>
1.6 Spring的JdbcTemplate
JdbcTemplate模板与DbUtils工具类比较类似.
1.6.1 Spring对持久层技术支持:
Spring为各种支持的持久化技术，都提供了简单操作的模板和回调
JDBC : org.springframework.jdbc.core.JdbcTemplate
Hibernate3.0 : org.springframework.orm.hibernate3.HibernateTemplate
IBatis(MyBatis) : org.springframework.orm.ibatis.SqlMapClientTemplate
JPA : org.springframework.orm.jpa.JpaTemplate
1.6.2 开发JDBCTemplate入门:
第一步:引入相应jar包:
导入Spring核心开发包到创建工程
spring-beans-3.2.0.RELEASE.jarspring-context-3.2.0.RELEASE.jar
spring-core-3.2.0.RELEASE.jar
spring-expression-3.2.0.RELEASE.jar
还需要下载commons-logging日志包
commons-logging-1.1.1.jar
导入JDBC模板开发包
spring-jdbc-3.2.0.RELEASE.jar
spring-tx-3.2.0.RELEASE.jar
* mysql驱动.
第二步:创建applicationContext.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">
<!-- 配置Spring默认的连接池 -->
<!-- <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="driverClassName" value="com.mysql.jdbc.Driver"/>（配置属性）（有set方法，才可通过property属性注入）
<property name="url" value="jdbc:mysql:///spring3_day02"/>
<property name="username" value="root"/>
<property name="password" value="123"/>
</bean> -->
<!-- 配置DBCP连接池 -->
<!-- <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">
<property name="driverClassName" value="com.mysql.jdbc.Driver"/>
<property name="url" value="jdbc:mysql:///spring3_day02"/>
<property name="username" value="root"/>
<property name="password" value="123"/>
</bean> -->
<!-- <bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
<property name="location" value="classpath:jdbc.properties"></property>
</bean> -->
<context:property-placeholder location="classpath:jdbc.properties"/>
<!-- 定义jdbctemplate -->
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
<property name="dataSource" ref="dataSource"/>
</bean>
<bean id="userDao" class="cn.itcast.spring3.demo2.UserDao">
<property name="jdbcTemplate" ref="jdbcTemplate"/>
</bean>
</beans>
第三步:编写一个测试类:
@Test
public void demo1(){
// 创建连接池:
DriverManagerDataSource dataSource = new DriverManagerDataSource();
// 设置参数:一般放在配置文件里，只创建一次就可以了
dataSource.setDriverClassName("com.mysql.jdbc.Driver");
dataSource.setUrl("jdbc:mysql:///spring3_day02");
dataSource.setUsername("root");
dataSource.setPassword("123");
// 使用JDBC的模板:
JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);//传入dataSource
jdbcTemplate.execute("create table user (id int primary key auto_increment,name varchar(20))");//执行sql语句
}
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class SpringTest1 {
@Autowired
@Qualifier("jdbcTemplate")
private JdbcTemplate jdbcTemplate;
@Test
public void demo2(){
jdbcTemplate.execute("create table user (id int primary key auto_increment,name varchar(20))");
}
1.6.3 配置连接池:
Spring默认的连接池:
<!-- 配置Spring默认的连接池 -->
<bean id="dataSource"class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="driverClassName" value="com.mysql.jdbc.Driver"/>
<property name="url" value="jdbc:mysql:///spring3_day02"/>
<property name="username" value="root"/>
<property name="password" value="123"/>
</bean>
DBCP连接池:
导入jar包:
* com.springsource.org.apache.commons.dbcp-1.2.2.osgi.jar
* com.springsource.org.apache.commons.pool-1.5.3.jar
<!-- 配置DBCP连接池 -->
<bean id="dataSource"class="org.apache.commons.dbcp.BasicDataSource">
<property name="driverClassName" value="com.mysql.jdbc.Driver"/>
<property name="url" value="jdbc:mysql:///spring3_day02"/>
<property name="username" value="root"/>
<property name="password" value="123"/>
</bean>
C3P0连接池:
导入jar包:
* com.springsource.com.mchange.v2.c3p0-0.9.1.2.jar
<!-- 配置c3p0连接池 -->
<bean id="dataSource"class="com.mchange.v2.c3p0.ComboPooledDataSource">
<property name="driverClass" value="com.mysql.jdbc.Driver"/>
<property name="jdbcUrl" value="jdbc:mysql:///spring3_day02"/>
<property name="user" value="root"/>
<property name="password" value="123"/>
</bean>
1.6.4 参数设置到属性文件中:
在src下创建jdbc.properties（名字随意起）
jdbc.driver = com.mysql.jdbc.Driver
jdbc.url = jdbc:mysql:///spring3_day02
jdbc.user = root
jdbc.password = 123
需要在applicationContext.xml中使用属性文件配置的内容.
* 第一种写法:
<bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
<property name="location"value="classpath:jdbc.properties"></property>
</bean>
* 第二种写法:（推荐）
<context:property-placeholder location="classpath:jdbc.properties"/>
<!-- 配置c3p0连接池 -->
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
<property name="driverClass" value="${jdbc.driver}"/>
<property name="jdbcUrl" value="${jdbc.url}"/>
<property name="user" value="${jdbc.user}"/>
<property name="password" value="${jdbc.password}"/>
</bean>
1.6.5 JdbcTemplate的CRUD的操作:
Spring框架中提供了对持久层技术支持的类:
JDBC : org.springframework.jdbc.core.support.JdbcDaoSupport
Hibernate 3.0 : org.springframework.orm.hibernate3.support.HibernateDaoSupport
iBatis : org.springframework.orm.ibatis.support.SqlMapClientDaoSupport
编写DAO的时候:
Public class UserDao extends JdbcDaoSupport{ //有set方法及JdbcTemplate模板
}
进行CRUD的操作;（增删改查）
* 保存:update(Stringsql,Object... args)
* 修改:update(Stringsql,Object... args)
* 删除:update(Stringsql,Object... args)
public void update(User user){
String sql = "update user set name = ? where id = ?";
this.getJdbcTemplate().update(sql, user.getName(),user.getId());
}
public void update(User user){
String sql = "update user set name = ? where id = ?";
this.getJdbcTemplate().update(sql, user.getName(),user.getId());
}
public void delete(User user){
String sql = "delete from user where id = ?";
this.getJdbcTemplate().update(sql, user.getId());
}
查询:（没有提供Handerler，需要手动封装一个）
* 简单查询:
* select count(*) from user; ---queryForInt(String sql);
* select name from user where id = ?; --- queryForObject(String sql,Class clazz,Object... args);
* 复杂查询:(返回对象,和对象集合)
* select * from user where id = ? ---queryForObjectString sql,RowMapper<T> rowMapper,Object... args);
* select * from user; ---query(String sql,RowMapper<T> rowMapper,Object... args);
public int findCount(){
String sql = "select count(*) from user";
return this.getJdbcTemplate().queryForInt(sql);
}
public String findNameById(int id){
String sql = "select name from user where id = ?";
return this.getJdbcTemplate().queryForObject(sql, String.class, id);//这里String.class是返回类型 ， 2是customer的id参数
}
public User findById(int id){
String sql = "select * from user where id = ?";
User user = this.getJdbcTemplate().queryForObject(sql, new UserRowMapper(), id);
return user;
}
public List<User> findAll(){
String sql = "select * from user";
return this.getJdbcTemplate().query(sql, new UserRowMapper());
}
class UserRowMapper implements RowMapper<User>{//手动封装，内部类
/**
* rs:结果集.
* rowNum:行号
*/
public User mapRow(ResultSet rs, int rowNum) throws SQLException {//不用遍历结果集，已经把结果集光标移向具体数据
User user = new User();
user.setId(rs.getInt("id"));
user.setName(rs.getString("name"));
return user;
}
}
测试：
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class SpringTest2 {
@Autowired
@Qualifier("userDao")
private UserDao userDao;
@Test
public void demo1(){
User user = new User();//正常情况：web传到业务层，业务层传到Dao
user.setName("小胖");
userDao.add(user);
}
}
内容总结:
Spring AOP
* AOP:面向切面编程.不是替代面向对象,对面向对象扩展,延伸.
* AOP的思想:
* 代理机制.(横向抽取).
* Spring使用AOP的时候,底层会根据类的情况,自动选择代理机制:
* JDK :针对实现了接口的类生成代理.
* CGLIB :针对没有实现接口的类生成代理.生成某个类的子类.
* Spring的AOP的开发中:
* 术语 :
* JoinPoint:连接点.可以被增强的方法.
* PointCut:切入点.真正被增强的方法.
* Advice:通知.增强的代码.
* Target:目标对象.被增强的类.
* Weaving:
* Aspect:切面.在切入点应用增强.
* 传统的Spring AOP.（先创建被代理对象，然后传入）
* 不带切点的切面:
* 带有切点的切面:
* 生成代理:基于ProxyFactoryBean.
* 缺点;每个类都需要配置ProxyFactroyBean.
* 自动代理:(基于后处理Bean)
* Bean名称自动代理:
* 切面信息自动代理:
* Spring中AspectJ的支持.
* 为了简便开发引入AspectJ的支持. （两种，选一种熟练）
* 注解:（需要开启一个配置，aop注解的自动代理）
* @Aspect:
* @Before
* @Around
* @AfterReturing
* @AfterThrowing
* @After
* PointCut
* XML:
* 引入aop约束:
<aop-config>
<aop:pointcut id=”” expression=””/>
<aop:aspect ref=””>
<aop:before />
</aop:aspect>
</aop-config>
Spring JDBCTemplate（模板,如不用Hibernate，就可以用JDBCTemplate模板）:
* 配置连接池:
* 默认的:
* DBCP:
* C3P0:(*****)
* 提取了properties
* JdbcTemplate的CRUD的操作.