为什么了借代理模式，因为代理模式是SpringAOP的底层，慎重万丈高楼平地起
代理模式有
- 静态代理模式动态代理模式
抽象角色：一般会使用接口类或者抽象类真实角色：被代理角色代理角色：代理真实角色，并有一些附属操作客户：访问代理对象的人 静态代理好处
缺点可以使真实角色的操作更加纯粹！不用去关注一些公共的业务公共也就交给代理角色！实现了业务的分工！公共业务发生扩展的时候，方便集中管理！一个真实角色就会产生一个代理角色；代码量会翻倍-开发效率会变低（最重要的一点）
研究方法一般因为有 需求，那需求来了，现在我们需要增加一个日志功能，怎么实现！
思路1 ：在实现类上增加代码 【麻烦！】思路2：使用代理来做，能够不改变原来的业务情况下就是不用动原始daim，实现此功能就是最好的了
2.动态代理
动态代理和静态代理角色一样
动态代理的代理类是动态生成的，不是 我们直接写好的！
动态代理分为两大类：基于接口的动态代理、基于类的动态代理
动态代理的好处：可以使真实角色的操作更加纯粹！不用去关注一些公共的业务公共也就交给代理角色！实现了业务的分工！公共业务发生扩展的时候，方便集中管理！一个动态代理类代理的是一个接口，一般就是对应的一类业务一个动态代理类可以代理多个类，只要是实现了同一个接口即可【核心】
这里需要了解两个类
Proxy：代理，
InvocationHandler：调用处理程序
了解完代理开始
3.代码实现建立三接口三实现类
- UserDaoScoreDaoStudentDaoUserDaoImplScoreDaoImplStudentDaoImpl
Dao 层下的代码
package com.sl.aop.dao;
public interface ScoreDao {
public void addScore();
public void deleteScore();
}
package com.sl.aop.dao;
public interface StudentDao {
public void addStudent();
public void deleteStudent();
}
package com.sl.aop.dao;
public interface UserDao {
public void addUser();
public void deleteUser();
}
Implement层代码如下
package com.sl.aop.Impl;
import com.sl.aop.dao.ScoreDao;
import org.springframework.stereotype.Repository;
@Repository("scoreDao")
public class ScoreDaoImpl implements ScoreDao {
@Override
public void addScore() {
//int i=10/0;
System.out.println("添加");
}
@Override
public void deleteScore() {
System.out.println("删除成绩");
}
}
package com.sl.aop.Impl;
import com.sl.aop.dao.StudentDao;
import org.springframework.stereotype.Repository;
@Repository("studentDao")
public class StudentDaoImpl implements StudentDao {
@Override
public void addStudent() {
//int i=10/0;
System.out.println("添加");
}
@Override
public void deleteStudent() {
System.out.println("删除成绩");
}
}
package com.sl.aop.Impl;
import com.sl.aop.dao.UserDao;
import org.springframework.stereotype.Repository;
@Repository("userDao")
public class UserDaoImpl implements UserDao {
@Override
public void addUser() {
// int i = 10 / 0;
System.out.println("添加");
}
@Override
public void deleteUser() {
System.out.println("删除成绩");
}
}
Log代码如下
package com.sl.aop.log;
import org.springframework.aop.AfterReturningAdvice;
import java.lang.reflect.Method;
public class AfterLog implements AfterReturningAdvice {
@Override
public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
System.out.println(
"执行了"+method.getName()+"结果为"+returnValue
);
}
}
package com.sl.aop.log;
import org.springframework.aop.MethodBeforeAdvice;
import java.lang.reflect.Method;
public class Log implements MethodBeforeAdvice {
@Override
public void before(Method method, Object[] args, Object target) throws Throwable {
System.out.println(
target.getClass().getName()+"的"+method.getName()+"执行"
);
}
}
point 切点类
package com.sl.aop.point;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.Signature;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
//注解方式去做aop
///标注这个类为切面
@Aspect
public class AnnotationPointCut {
@Before("execution(* com.sl.aop.Impl.ScoreDaoImpl.*(..))")
public void scorebefor() {
System.out.println("score方法前使用这个方法");
}
@Before("execution(* com.sl.aop.Impl.StudentDaoImpl.*(..) )")
public void studentbefor() {
System.out.println("student方法前使用这个方法");
}
@Before("execution(* com.sl.aop.Impl.UserDaoImpl.*(..) )")
public void userbefor() {
System.out.println("user方法前使用这个方法");
}
@After("execution(* com.sl.aop.Impl.ScoreDaoImpl.*(..))")
public void scoreafter() {
System.out.println("scoreafter方法后使用这个方法");
}
@After("execution(* com.sl.aop.Impl.StudentDaoImpl.*(..))")
public void studentafter() {
System.out.println("studentafter方法后使用这个方法");
}
@After("execution(* com.sl.aop.Impl.UserDaoImpl.*(..))")
public void userafter() {
System.out.println("userafter方法后使用这个方法");
}
//在环绕增强中 ，我们可以给定一个参数，代表我们要获取这个参数的切入点
@Around("execution(* com.sl.aop.Impl.ScoreDaoImpl.*(..))")
public void Scorearound(ProceedingJoinPoint jp) throws Throwable {
System.out.println("环绕前");
//获得签名
Signature signature = jp.getSignature();
System.out.println(jp.getSignature() + "Signature");
//执行前 过滤
Object proceed = jp.proceed();
System.out.println("环绕后");
}
@Around("execution(* com.sl.aop.Impl.StudentDaoImpl.*(..))")
public void Studentaround(ProceedingJoinPoint jp) throws Throwable {
System.out.println("环绕前");
//获得签名
Signature signature = jp.getSignature();
System.out.println(jp.getSignature() + "Signature");
//执行前 过滤
Object proceed = jp.proceed();
System.out.println("环绕后");
}
@Around("execution(* com.sl.aop.Impl.UserDaoImpl.*(..))")
public void Useraround(ProceedingJoinPoint jp) throws Throwable {
System.out.println("环绕前");
//获得签名
Signature signature = jp.getSignature();
System.out.println(jp.getSignature() + "Signature");
//执行前 过滤
Object proceed = jp.proceed();
System.out.println("环绕后");
}
}
package com.sl.aop.point;
public class Point {
public void before() {
System.out.println("+方法执行前+");
}
public void after() {
System.out.println("+方法执行后+");
}
}
配置XML 并注册bean applicationContext.xml
Mytext测试类
import com.sl.aop.dao.UserDao;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class Mytest {
public static void main(String[] args) {
//动态代理得是接口 不是实现类
ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
UserDao userDao =(UserDao)context.getBean("userDao");
userDao.addUser();
}
}
运行结果
这就是代理，也是典型的不用动原代码，并给他加上附加功能 ，日志什么的
但是我这个太傻了，不同方法需要些不同的方法日志
革命尚未结束，同志还需努力
