Spring_java_内存溢出

AOP概念

1、利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，提高开发效率

2、通俗的讲，不修改源代码的方式，在主干里面添加新的功能

AOP的底层原理

a) AOP底层是用动态代理

第一种有接口的情况，使用JDK动态代理，创建这个接口实现类的代理对象，增强类的方法
第二种没有接口情况，使用CGLIB动态代理创建子类的代理对象，增强类的方法

AOP(JDK动态代理)

a）使用JDK动态代理，使用Proxy类里面的方法创建代理对象

public static Object newProxyInstance(ClassLoader loader,
                                      Class<?>[] interfaces,
                                      InvocationHandler h)

第一个参数，类加载器
第二个参数，增强方法所在的类，这个类实现的接口，支持多个类型
第三个参数，实现这个接口InvocationHandler,创建代理对象，写增强的部分

b) 编写JDK动态代理代码

//接口
public interface UserDao {
    public int add(int a ,int b);
    public String update(String id);
}

//实现类
public class UserDaoImpl implements UserDao {
    @Override
    public int  add(int a, int b) {
        return a+b;
    }

    @Override
    public String  update(String str) {
        return str;
    }
}

//测试，jdk动态代理
public class JDKProxy {
    public static void main(String[] args) {
//        创建接口实现类代理对象
        Class[] interface_ = {UserDao.class};
//        创建一个实列
        UserDaoImpl userDao = new UserDaoImpl();
        UserDao o = (UserDao) Proxy.newProxyInstance(JDKProxy.class.getClassLoader(), interface_, new Temp(userDao));
        int add = o.add(1, 8);
        System.out.println("结果："+add);
        System.out.println("==========================");
        String update = o.update("小浩纸~~");
        System.out.println(update);
    }
}
//创建对象代理类
class Temp implements InvocationHandler{
//    通过有参的构造方法传递参数
    public Object obj;
    public  Temp(Object obj){
        this.obj=obj;
    }


//  增强逻辑的代码
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
//        方法之前
        System.out.println("方法执行前："+method.getName()+"传递参数的个数："+ Arrays.toString(args));
//        被增强的方法执行
        Object res = method.invoke(obj, args);
        System.out.println("方法执行后:"+obj);
        return res;

    }
}

AOP术语

1、连接点：类里面那些方法可以被增强，这些方法称之为连接点
2、切入点：实际被真正增强的方法，称之为切入点
3、通知（增强）：实际增强的逻辑部分称之为通知（增强）
>前置通知 >后置通知 >环绕通知 >异常通知 >最终通知 finally
4、切面：是动作把通知应用道切入点过程

AOP *** 作

a）Spring 框架一般都是基于 AspectJ 实现 AOP *** 作，AspectJ 不是 Spring 组成部分，独立 AOP 框架，一般把 AspectJ 和 Spirng 框架一起使用，进行 AOP *** 作

b）基于 AspectJ 实现 AOP *** 作：1）基于 xml 配置文件实现（2）基于注解方式实现（使用）

c）引入相关jar包

d）切入点表达式，如下：

（1）切入点表达式作用：知道对哪个类里面的哪个方法进行增强 
（2）语法结构： execution([权限修饰符] [返回类型] [类全路径] [方法名称]([参数列表]) )
（3）例子如下：
    例 1：对 com.atguigu.dao.BookDao 类里面的 add 进行增强
		execution(* com.atguigu.dao.BookDao.add(..))
 	例 2：对 com.atguigu.dao.BookDao 类里面的所有的方法进行增强
		execution(* com.atguigu.dao.BookDao.* (..))
    例 3：对 com.atguigu.dao 包里面所有类，类里面所有方法进行增强
		execution(* com.atguigu.dao.*.* (..))

AOP *** 作（AspectJ注解）

a) 基于注解 aop *** 作步骤
1、被增强类

//被增强的类
    @Component   //基于注解的方式
public class User {
    public void add(){
        System.out.println("add........");
    }
}

2、创建增强类

//增强的类  ，写增强的方法
    @Component
    @Aspect   //生成代理对象 ，在增强类上面添加
public class UserProxy {
//    作为前置通知   使用切入点表达式配置
    @Before(value = "execution(* com.zh.Day_04.Bean_demo_05.User.add(..))")
    public void before(){
        System.out.println("before....... 前置通知");
    }
//    后置通知
    @AfterReturning(value = "execution(* com.zh.Day_04.Bean_demo_05.User.add(..))")
    public void AfterReturning(){
        System.out.println("AfterReturning....... 后置通知");
    }
//    最终通知
    @After(value = "execution(* com.zh.Day_04.Bean_demo_05.User.add(..))")
    public void after(){
        System.out.println("after....... 最终通知");
    }
//    异常通知
    @AfterThrowing(value = "execution(* com.zh.Day_04.Bean_demo_05.User.add(..))")
    public void AfterThrowing(){
        System.out.println("AfterThrowing....... 异常通知");
    }
//    环绕通知
    @Around(value = "execution(* com.zh.Day_04.Bean_demo_05.User.add(..))")
    public void Around(ProceedingJoinPoint p) throws Throwable {
        System.out.println("Around....... 环绕之前通知");
        p.proceed();
        System.out.println("Around....... 环绕之后通知");
    }
}

3、XIM方式配置


<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"
       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/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
">

    <context:component-scan base-package="com.zh.Day_04.Bean_demo_05">context:component-scan>

    <aop:aspectj-autoproxy>aop:aspectj-autoproxy>
beans>

4、测试

//测试
public class Test {
    public static void main(String[] args) {
        ClassPathXmlApplicationContext context
                = new ClassPathXmlApplicationContext("com/zh/Day_04/Bean_demo_05/bean.xml");
        User user = context.getBean("user", User.class);
        user.add();
    }
}

b）基于 aop注解中，2个细节问题
1、相同切入点的抽取

//        切入点的抽取
    @Pointcut(value="execution(* com.zh.Day_04.Bean_demo_05.User.add(..))")
    public void dome(){

    }
    

//    作为前置通知   使用切入点表达式配置
    @Before(value ="dome()")
    public void before(){
        System.out.println("before....... 前置通知");
    }

2、有多个增强类的时候，同一个方法进行增强的时候，可以设置优先级

//也是个增强类   两个类里面的方法同时增强一个类的时候 ，数字越小，优先级越高
    @Component
    @Aspect
    @Order(1)    //数字越小，优先级越高
public class UserProxy_demo {
    @Before(value ="execution(* com.zh.Day_04.Bean_demo_05.User.add(..))")
    public void before(){
        System.out.println("before111....... 前置通知");
    }
}

c）完全使用注解来开发

@Configuration //配置类
@ComponentScan(basePackages = {"com.atguigu"})  //开启组件扫描
@EnableAspectJAutoProxy(proxyTargetClass = true) //默认是false 代替了 生成代理对象
public class ConfigAop {
}

AOP *** 作（基于XML方式）（不推荐）

1、被增强类

//被增强类
public class User {
    public void aaa(){
        System.out.println("add....");
    }
}

2、增强类

//增强类
public class UserProxy {
    public void show(){
        System.out.println("show");
    }

}

3、配置文件


<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"
       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/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">


    <bean id="user" class="com.zh.Day_04.Bean_demo_06.User">bean>
    <bean id="userProxy" class="com.zh.Day_04.Bean_demo_06.UserProxy">bean>

    <aop:config>

        <aop:pointcut id="p" expression="execution(* com.zh.Day_04.Bean_demo_06.User.aaa(..))"/>


        <aop:aspect ref="userProxy">

            <aop:before method="show" pointcut-ref="p">aop:before>
        aop:aspect>
    aop:config>
beans>

4、测试

public class Test {
    public static void main(String[] args) {
        ClassPathXmlApplicationContext context
                = new ClassPathXmlApplicationContext("com/zh/Day_04/Bean_demo_06/bean.xml");
        User user = context.getBean("user", User.class);
        user.aaa();
    }
}

欢迎分享，转载请注明来源：内存溢出

原文地址: http://outofmemory.cn/langs/905670.html

Spring

发表评论

评论列表（0条）