Spring原生的经典模式 实现 AOP
通知：
前置通知：在目标方法执行之前执行，不能改变方法的执行流程和结果！
实现 MethodBeforeAdvice接口！
后置通知：在目标方法执行之后执行，不能改变方法的执行流程和结果！
实现 AfterReturningAdvice接口！
环绕通知：方法的拦截器！可以改变方法的执行流程和结果！
实现 MethodInterceptor接口！
异常通知：当我们的目标方法出现异常时才执行的方法！
实现ThrowsAdvice接口！
实现各种增强（通知 advice）的步骤：
01.引入两个jar 一个是aop联盟 spring-aop
02.创建对应的接口和实现类(主业务)
03.创建对应的增强处理类（系统级业务）
04.在spring容器中配置 目标类对象和通知对象
05.配置ProxyFactoryBean(代理工厂类）
问题：
01.如果我们有多个serviceImpl！ 这时候ProxyFactoryBean不能配置多个目标对象！
02.ProxyFactoryBean给目标对象中的所有主业务都做了增强！不能指定某个主业务！
<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/xsd/maven-4.0.0.xsd"> <parent> <artifactId>Spring</artifactId> <groupId>com.xdf</groupId> <version>1.0-SNAPSHOT</version> </parent> <modelVersion>4.0.0</modelVersion> <artifactId>09SpringAop</artifactId> <packaging>jar</packaging> <name>09SpringAop</name> <url>http://maven.apache.org</url> <properties> <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> <!--spring对应的版本号--> <spring.version>4.2.1.RELEASE</spring.version> </properties> <dependencies> <dependency> <groupId>aopalliance</groupId> <artifactId>aopalliance</artifactId> <version>1.0</version> </dependency> <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>4.0</version> <scope>test</scope> </dependency> <!--引入需要的spring 核心jar--> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-context</artifactId> <version>${spring.version}</version> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-core</artifactId> <version>${spring.version}</version> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-aop</artifactId> <version>${spring.version}</version> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-beans</artifactId> <version>${spring.version}</version> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-expression</artifactId> <version>${spring.version}</version> </dependency> <dependency> <groupId>commons-logging</groupId> <artifactId>commons-logging</artifactId> <version>1.1.1</version> </dependency> <!--引入mysql的驱动包--> <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <version>5.1.26</version> </dependency> <!--配置jdbc需要的数据源--> <dependency> <groupId>commons-pool</groupId> <artifactId>commons-pool</artifactId> <version>1.6</version> </dependency> <dependency> <groupId>commons-dbcp</groupId> <artifactId>commons-dbcp</artifactId> <version>1.4</version> </dependency> <dependency> <groupId>c3p0</groupId> <artifactId>c3p0</artifactId> <version>0.9.1.2</version> </dependency> <!--SpringJDBC需要的jar--> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-jdbc</artifactId> <version>${spring.version}</version> </dependency> </dependencies> </project>
public interface UserService { //主业务 String eat(); //主业务 void sleep(); }
// 目标类 impl包下的UserServiceImpl public class UserServiceImpl implements UserService{ //主业务 public String eat() { System.out.println("正在吃小苹果......"); return "apple"; } //主业务 public void sleep() { System.out.println("正在休息......"); } }
定义的通知（增强）
//异常通知 public class ExceptionAdvice implements ThrowsAdvice { /** * @param ex 用户名异常 */ public void afterThrowing(UserNameException ex){ System.out.println(ex.getMessage()); } /** * @param ex 年龄异常 */ public void afterThrowing(AgeException ex){ System.out.println(ex.getMessage()); } }
//前置通知 public class BeforeAdvice implements MethodBeforeAdvice { /** * 在目标方法执行之前 * @param method 目标方法 * @param args 目标方法的参数列表 * @param target 目标对象 * @throws Throwable */ public void before(Method method, Object[] args, Object target) throws Throwable { /* System.out.println("target的名称====》"+target); System.out.println("method的名称====》"+method.getName());*/ System.out.println("执行**** 前置**** 通知"); } }
//环绕通知 public class AroundAdvice implements MethodInterceptor { /** * 在前置通知 之后，后置通知之前执行环绕通知！ * 可以获取方法的返回值，并且改变！ * @param methodInvocation 方法的执行器， getMethod 包含了方法中的所有方法 * @return */ public Object invoke(MethodInvocation methodInvocation) throws Throwable { System.out.println("执行方法之前的 环绕通知"); //执行目标方法 Object result= methodInvocation.proceed(); if (result!=null){ result="xiaoheihei"; } System.out.println("执行方法之后的 环绕通知"); return result; } }
//后置通知 public class AfterAdvice implements AfterReturningAdvice { /** * 在目标方法执行之后 * @param returnValue 目标方法的返回值 我们可以获取返回值 但是不能操作返回值 * @param method 目标方法 * @param args 目标方法的参数列表 * @param target 目标对象 * @throws Throwable */ public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable { /* System.out.println("target的名称====》"+target); System.out.println("returnValue====》"+returnValue); System.out.println("method的名称====》"+method.getName());*/ System.out.println("执行**** 后置**** 通知"); } }
定义的异常文件夹
//验证异常通知的接口 public interface ExceptionService { public boolean checkUser(String userName,int age) throws UserException; }
public class UserServiceImpl implements ExceptionService { public boolean checkUser(String userName, int age) throws UserException { if (!"admin".equalsIgnoreCase(userName)){ throw new UserNameException("用户名错误"); } if (age<20){ throw new AgeException("年龄错误"); } return true; } }
//用户的异常类 public class UserException extends Exception{ public UserException(String msg){ super(msg); } }
//用户名异常类 public class UserNameException extends UserException { public UserNameException(String msg) { super(msg); } }
//年龄异常类 public class AgeException extends UserException { public AgeException(String msg) { super(msg); } }
<?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" 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"> <bean id="userService" class="cn.happy.service.impl.UserServiceImpl"/> <bean id="before" class="cn.happy.service.advices.BeforeAdvice"/> <bean id="after" class="cn.happy.service.advices.AfterAdvice"/> <bean id="around" class="cn.happy.service.advices.AroundAdvice"/> <bean id="userException" class="cn.happy.service.exceptionPackage.UserServiceImpl"/> <bean id="myException" class="cn.happy.service.advices.ExceptionAdvice"/> <!--03.通知配置代理工厂bean,生成代理类，来把通知织入到目标对象 问题：只能管理 通知！ 01.只能将切面织入到目标类的所有方法中 02.只能配置一个目标对象 --> <bean id="userProxy" class="org.springframework.aop.framework.ProxyFactoryBean"> <property name="target" ref="userService"/> <!--前置，后置的通知： value第一种方法--> <!--<property name="interceptorNames" value="before,after"/>--> <!--前置，后置，环绕的通知 value第二种方法--> <property name="interceptorNames"> <array><!--这里要定义array--> <value>before</value> <value>after</value> <value>around</value> </array> </property> </bean> <bean id="exceptionProxy" class="org.springframework.aop.framework.ProxyFactoryBean"> <property name="targetName" value="userException"/> <property name="interceptorNames"> <array> <value>myException</value> </array> </property> <!--代理类的优化 是否使用cglib动态代理--> <property name="optimize" value="true"/> </bean> </beans>
<property name="proxyTargetClass" value="true"/> proxyTargetClass:默认是false,默认执行jdk动态代理！ 设置成true,强制执行cglib! optimize:代理类的优化 有接口就是用jdk,没有接口使用cglib动态代理
我们的动态代理 （在程序运行期间，动态生成的代理类） 分为两种方式： 01.jdk 只能应用于实现接口的情况 02.cglib 应用于实现接口和类的情况
如果我们是接口的情况，使用jdk效率高！ 如果我们是类的情况，必须使用cglib！
问题？ 程序 spring容器怎么知道我们是用的类还是接口？？ public class ProxyConfig implements Serializable private boolean proxyTargetClass = false; private boolean optimize = false; spring底层默认使用cglib！ 现在我们的项目中使用的是接口！ 用spring默认的性能不高！ proxyTargetClass 和optimize都是用来设置 我们使用的代理模式是jdk还是cglib！
@Override public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException { // 根据我们配置文件中 proxyTargetClass 和 optimize的配置 if (config.isOptimize() || config.isProxyTargetClass() || hasNoUserSuppliedProxyInterfaces(config)) { Class<?> targetClass = config.getTargetClass(); if (targetClass == null) { throw new AopConfigException("TargetSource cannot determine target class: " + "Either an interface or a target is required for proxy creation."); } //根据目标对象返回对应的动态代理 if (targetClass.isInterface() || Proxy.isProxyClass(targetClass)) { return new JdkDynamicAopProxy(config); } return new ObjenesisCglibAopProxy(config); } else { return new JdkDynamicAopProxy(config); } }