主要参考资料:【狂神说Spring】
1.1、AOP
面向切面编程,作为面向对象的一种补充,将公共逻辑(事务管理、日志、缓存等)封装成切面,跟业务代码,跟业务代码进行分离,可以减少系统的重复代码和降低模块之间的耦合度。AOP有静态代理和动态代理两种实现方式。
1.2、静态代理
静态代理角色分析:
- 抽象角色:一般使用接口或者抽象类来实现
- 真实对象:被代理的角色
- 代理角色:代理真实角色;代理真实角色后,一般会做一些附属的操作
- 客户:使用代理角色来进行一些操作
1.3、静态代理代码实现
以租房为例:
Rent.java
package com.guhuo.pojo;
public interface Rent {
public void rent();
}
Host.java
package com.guhuo.pojo;
public class Host implements Rent{
@Override
public void rent() {
System.out.println("房屋出租");
}
}
Proxy.java
package com.guhuo.pojo;
public class Proxy implements Rent {
private Host host;
public Proxy() {
}
public Proxy(Host host) {
this.host = host;
}
@Override
public void rent() {
seeHouse();
host.rent();
fare();
}
//看房
public void seeHouse() {
System.out.println("带房客看房");
}
//收中介费
public void fare() {
System.out.println("收中介费");
}
}
Client.java
package com.guhuo.pojo;
//客户类,一般客户都会去找代理!
public class Client {
public static void main(String[] args) {
//房东要租房
Host host = new Host();
//中介帮助房东
Proxy proxy = new Proxy(host);
//你去找中介!
proxy.rent();
}
}
静态代理的好处:
- 可以使得我们的真实角色更加纯粹 . 不再去关注一些公共的事情 .
- 公共的业务由代理来完成 . 实现了业务的分工 ,
- 公共业务发生扩展时变得更加集中和方便 .
缺点 :
- 类多了 , 多了代理类 , 工作量变大了 . 开发效率降低 .
1.4、静态代理再理解
真实业务:
UserService业务接口:
package com.guhuo.service;
public interface UserService {
void add();
void delete();
void update();
void query();
}
业务实现类:UserServiceImpl
package com.guhuo.service;
public class UserServiceImpl {
public void add() {
System.out.println("增加了一个用户");
}
public void delete() {
System.out.println("删除了一个用户");
}
public void update() {
System.out.println("更新了一个用户");
}
public void query() {
System.out.println("查询了一个用户");
}
}
增加一个需求时:设置一个代理类来处理日志!代理角色
package com.guhuo.service;
public class UserServiceProxy implements UserService {
private UserServiceImpl userService;
public void setUserService(UserServiceImpl userService) {
this.userService = userService;
}
public void add() {
log("add");
userService.add();
}
public void delete() {
log("delete");
userService.delete();
}
public void update() {
log("update");
userService.update();
}
public void query() {
log("query");
userService.query();
}
public void log(String msg){
System.out.println("执行了"+msg+"方法");
}
}
测试类
package com.guhuo.service;
import com.guhuo.pojo.Host;
import com.guhuo.pojo.Proxy;
public class Client {
public static void main(String[] args) {
// 真实业务
UserServiceImpl userService = new UserServiceImpl();
// 代理类
UserServiceProxy proxy = new UserServiceProxy();
// 使用代理类实现日志功能
proxy.setUserService(userService);
proxy.add();
}
}
1.5、动态代理
概念:代理类在程序运行时创建,AOP框架不会去修改字节码,而是在内存中临时生成一个代理对象,在运行期间对业务方法进行增强,不会生成新类。
- 动态代理和静态代理角色一样
- 动态代理的代理类是动态生成的,不是我们直接写好的!
- 动态代理分为两大类:基于接口的动态代理,基于类的动态代理
- 基于接口的动态代理:JDK动态代理,此处我们使用这一种方式实现动态代理
- 基于类:cglib
- java字节码实现:javasist
需要了解两个类:Proxy(代理)和InvocationHeadler:调用处理程序。
Rent接口
package AOP.demo01;
public interface Rent {
public void rent();
}
Host实现Rent接口
package AOP.demo01;
public interface Rent {
public void rent();
}
ProxyInvocationHandler
package AOP.demo02;
import AOP.demo01.Rent;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
public class ProxyInvocationHandler implements InvocationHandler {
// 被代理的接口
private Object target;
public void setRent(Rent rent){
this.target = rent;
}
// 生成得到代理类
public Object getProxy(){
return Proxy.newProxyInstance(this.getClass().getClassLoader(),
target.getClass().getInterfaces(), this);
}
@Override
// 处理代理实例,返回代理结果
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
// 动态代理的本质就是使用反射机制
Object result = method.invoke(target, args);
return null;
}
}
Client类
package AOP.demo01;
public class Client {
public static void main(String[] args) {
// 真实角色
Host host = new Host();
// 代理角色:现在没有
ProxyInvocationHandler pih = new ProxyInvocationHandler();
// 通过调用程序处理角色来处理我们要调用的接口对象!
pih.setRent(host);
Rent proxy = (Rent) pih.getProxy(); // 这里的proxy就是动态生成的,我们并没有去写他
proxy.rent();
}
}
1.6、Spring AOP
三种实现方式:
- 使用Spring的API接口
- 自定义实现AOP
- 使用注解实现 @Aspect