爱上源码，重学Spring AOP深入

AOP （Aspect Orient Programming）：直译过来就是 面向切面编程。AOP 是一种编程思想

用途：Transactions （事务调用方法前开启事务， 调用方法后提交关闭事务 ）、日志、性能（监控方法运行时间）、权限控制等

也就是对业务方法做了增强

1.1 Spring AOP环境介绍

目标：认识AOP基础环境，后面讲使用这个基础环境进行源码讲解

tips：

沿用ioC的工厂

1）引入起步依赖
    compile(project(':spring-aop'))
    compile(project(':spring-context'))
    compile 'org.aspectj:aspectjweaver:1.9.2'
2）新建接口和实现
public interface Slaver {
    void work();
}

import org.springframework.stereotype.Service;

@Service
public class SlaverImpl implements Slaver {
    public void work() {
        System.out.println("进入实现类 work.....");
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

    }

}
3）新建切面类
package com.spring.test.aop.aop;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

import java.util.Arrays;

//将这个类声明为一个切面，需要将其放入IOC容器中
@Aspect//声明这是一个切面
@Component//声明这是一个组件
/**
 * 执行顺序
 * @Around进入环绕通知...
 * @Before进入前置通知:[]
 * 进入实现类 work.....
 * @Around方法执行耗时>>>>>: 1001
 * @After进入后置通知...
 * @AfterReturning进入最终通知...End!
 */
public class SlaverAspect {

    //环绕通知（连接到切入点开始执行，下一步进入前置通知，在下一步才是执行操作方法）
    @Around(value = "pointCut()")
    public void around(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("@Around进入环绕通知...");
        long startTime = System.currentTimeMillis();
        joinPoint.proceed();
        long endTime = System.currentTimeMillis();
        System.out.println(String.format("@Around方法执行耗时>>>>>: %s", endTime - startTime));
    }

    //前置通知（进入环绕后执行，下一步执行方法）
    @Before(value = "pointCut()")
    public void before(JoinPoint joinPoint) {
        System.out.println("@Before进入前置通知:" + Arrays.toString(joinPoint.getArgs()));
    }

    //异常通知（出错时执行）
    @AfterThrowing(value = "pointCut()", throwing = "ex")
    public void afterThrowing(JoinPoint joinPoint, Throwable ex) {
        System.out.println("@AfterThrowing进入异常通知" + Arrays.toString(joinPoint.getArgs()));
        System.out.println("@AfterThrowing异常信息：" + ex);
    }

    //后置通知(返回之前执行)
    @After(value = "pointCut()")
    public void after() {

        System.out.println("@After进入后置通知...");
    }

    //最终通知（正常返回通知，最后执行）
    @AfterReturning(value = "pointCut()")
    public void afterReturning() {
        System.out.println("@AfterReturning进入最终通知...End!");
    }

    //定义一个切入点 后面的通知直接引入切入点方法pointCut即可
//    @Pointcut("execution(public * com.spring.test.aop.impl.SlaverImpl.work())")
    @Pointcut(value = "execution(* com.spring.test.aop.impl.SlaverImpl.*(..))")
    public void pointCut() {
    }

}

AspectJ 支持 5 种类型的通知注解:
@Before: 前置通知, 在方法执行之前执行
@After: 后置通知, 在方法执行之后执行
@AfterRunning: 返回通知, 在方法返回结果之后执行
@AfterThrowing: 异常通知, 在方法抛出异常之后
@Around: 环绕通知, 围绕着方法执行

execution：用于匹配方法执行的连接点；

4）新建配置文件

resources/application-aop.xml

常见错误

配置文件缺乏xsd的引用

爱上源码，重学Spring AOP深入_第1张图片

5）新建入口类
public class Main {

    public static void main(String[] args) {
        ApplicationContext context =
                new ClassPathXmlApplicationContext("classpath*:application-aop.xml");
        Slaver slaver=(Slaver)context.getBean("slaverImpl");
        slaver.work();
    }

}
6）运行效果

爱上源码，重学Spring AOP深入_第2张图片

1.2 SpringAOP和AspectJ联系

tips：

十个人有九 个人弄不懂的关系

Spring AOP:

Spring AOP旨在通过Spring IoC提供一个简单的AOP实现，以解决编码人员面临的最常出现的问题。这并不是完整的AOP解决方案，它只能用于Spring容器管理的beans。

AspectJ：

AspectJ是最原始的AOP实现技术，提供了完整的AOP解决方案。AspectJ更为健壮，相对于Spring AOP也显得更为复杂

爱上源码，重学Spring AOP深入_第3张图片

总结

AOP是面向切面的一个思想
他有两种实现
1、Spring AOP
2、Aspectj
Spring AOP的实现没有AspectJ强大
所以，Spring把Aspectj给集成（如果用，还需要单独引jar）进来了
但是；spring aop已能满足我们的需求
在进行开发时候，这两个框架是完全兼容的

说白了，就是两个框架能一起使用，就看你项目需求用到的哪种程度了
简单的；spirng aop够用了，但是spring aop借助了aspectj的注解功能，
在高级点，比如切面很多，上万个，这是就要用到aspectj的高级功能了

区别：AspectJ使用的是编译期和类加载时进行织入，Spring AOP利用的是运行时织入

依赖：如果使用@Aspect注解，在xml里加上。但是这需要额外的jar包（ aspectjweaver.jar）

因为spring直接使用AspectJ的注解功能，注意只是使用了它 的注解功能而已。并不是核心功能 ！

运行效果如下：

爱上源码，重学Spring AOP深入_第4张图片

1.3 找到处理AOP的源头

1、Spring处理AOP源头在哪里(织入)

AspectJ编译期和类加载时进行织入、Spring AOP利用的是运行时织入 
猜想：
1. 在容器启动时创建？

2.在getBean时创建？
容器启动

2、代理对象到底长什么样？

将断点打在getBean的返回对象上，发现这并不是一个我们定义的对象本身，而是一个Proxy

爱上源码，重学Spring AOP深入_第5张图片

接下来，我们会找到$Proxy生成的始末

3、我的接口是怎么被A0P管理上的 ？

com.spring.test.aop.aop.SlaverAspect#pointCut

//定义一个切入点 后面的通知直接引入切入点方法pointCut即可
    //参数：
    //第一个”*“符号;表示返回值的类型任意
    //.*(..)表示任何方法名，括号表示参数，两个点表示任何参数类型
    @Pointcut(value = "execution(* com.spring.test.aop.impl.SlaverImpl.*(..))")
    public void pointCut() {
        System.out.println("@进入切点...");
    }

tips：

当然是execution声明，改成 SlaverImpl.aaaa*(..) ， 再来看getBean的对象，不再是proxy

断点一下……

1.4 代理对象是怎么生成的

1、AOP其实就是用的动态代理模式，创建代理

2、AOP织入源头在哪里

目标：通过源头找代理对象是如何生成的

​ 找到生成代理的地方Proxy.newProxyInstance

0）回顾助学

简单回顾一下，注意，这里不仅仅是学习代理模式，还必须搞懂它的实现方式，尤其是动态代理。

开始之前，我们先必须搞懂一件事情：

那就是：代理模式

设计模式【静态代理】 【动态代理】 回顾 （见第2小节）

1）从源头找代理对象生成

记住目标：

spring aop使用的就是代理模式，那我们的目标就明确了：找到生成代理的地方Proxy.newProxyInstance

先来张流程图：

下面我们沿着图中的调用链，找到aop 代理诞生的地方

爱上源码，重学Spring AOP深入_第6张图片

tips：从后置处理器开始

为什么要从后置处理器入手？

很容易理解，没初始化好没法用，等你初始化好了功能齐备了，我再下手，代替你

找到后置处理器

重点关注postProcessAfterInitialization

此处最好使用断点表达式，否则要循环很多次

因为在refresh方法中的invokeBeanFactoryPostProcessors方法也会调用到这个地方

断点表达式：

爱上源码，重学Spring AOP深入_第7张图片

关注点：

tips：

在BeanPostProcessor循环中，观察AnnotationAwareAspectJAutoProxyCreator

这货就是切面的后置处理器

AbstractAutowireCapableBeanFactory#applyBeanPostProcessorsAfterInitialization

    //目标：循环所有的后置处理器进行调用
    //注意：
    //AOP调试，此处最好使用断点表达式，否则要循环很多次
    //因为在refresh方法中的invokeBeanFactoryPostProcessors方法也会调用到这个地方
    @Override
    public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
            throws BeansException {

        Object result = existingBean;
        //aop
        //此处getBeanPostProcessors()有8个内置后置处理器；生成代理会调用里面的 AnnotationAwareAspectJAutoProxyCreator
        for (BeanPostProcessor beanProcessor : getBeanPostProcessors()) {
            //Aop调用AbstractAutoProxyCreator#postProcessAfterInitialization,
            Object current = beanProcessor.postProcessAfterInitialization(result, beanName);
            if (current == null) {
                return result;
            }
            result = current;
        }
        return result;
    }

如上所见

也就是说AOP模块是通过实现BeanPostProcessor集成进来的

2）进入后置处理器

tips:

aop这是spring内置的一个后置处理器，生效在postProcessAfterInitialization方法

AbstractAutoProxyCreator#postProcessAfterInitialization

重点关注wrapIfNecessary

    //如果当前的bean适合被代理，则需要包装指定的bean
    @Override
    public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) throws BeansException {
        if (bean != null) {
            // 根据给定的bean的class和name构建一个key
            Object cacheKey = getCacheKey(bean.getClass(), beanName);
            if (!this.earlyProxyReferences.contains(cacheKey)) {

                // 如果当前的bean适合被代理，则需要包装指定的bean
                return wrapIfNecessary(bean, beanName, cacheKey);
            }
        }
        return bean;
    }

经历wrapIfNecessary方法，重点关注点有两个：

1是：getAdvicesAndAdvisorsForBean，找到哪些切面会作用在当前bean上，满足条件的抓出来！

2是：createProxy，生成代理，替代slaverImpl去做事

    //目标
    //1、判断当前bean是否已经生成过代理对象，或者是否是应该被略过的对象，是则直接返回，否则进行下一步
    //2、拿到切面类中的所有增强方法（拦截器：环绕、前置、后置等）
    //3、生成代理对象
    protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
        // 判断是否为空
        // 判断当前bean是否在TargetSource缓存中存在，如果存在，则直接返回当前bean
        if (StringUtils.hasLength(beanName) && this.targetSourcedBeans.contains(beanName)) {
            return bean;
        }
        // 这里advisedBeans缓存了不需要代理的bean（为false的），如果缓存中存在，则可以直接返回
        if (Boolean.FALSE.equals(this.advisedBeans.get(cacheKey))) {
            return bean;
        }
        //Infrastructure基础设施
        // 用于判断当前bean是否为Spring系统自带的bean，自带的bean是
        // 不用进行代理的；shouldSkip()则用于判断当前bean是否应该被略过
        if (isInfrastructureClass(bean.getClass()) || shouldSkip(bean.getClass(), beanName)) {
            // 对当前bean进行缓存
            this.advisedBeans.put(cacheKey, Boolean.FALSE);
            return bean;
        }
    
    
    
    
    
        //AOP:【关键点1】反射来过滤，看看哪些aspect的execution能匹配上当前bean
        // ===【【【【注意！这货要分两步调试讲解，修改切面表达式做对比】】】】====
        // 将SlaverAspect的 execution改成 SlaverImpl.aaa*(..)  试试，你将得到一个空数组！！！
        // 匹配上的话列出前后和置换的方法（拦截器：环绕、前置、后置等）
        Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);

    
    
        //如果拿到的增强方法不为空
        if (specificInterceptors != DO_NOT_PROXY) {
            // 对当前bean的代理状态进行缓存
            this.advisedBeans.put(cacheKey, Boolean.TRUE);
      
      
      
            // 开始创建AOP代理
      //  ===【关键点2】===
            Object proxy = createProxy(
                    bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));
      
      
      
      
            // 缓存生成的代理bean的类型，并且返回生成的代理bean
            this.proxyTypes.put(cacheKey, proxy.getClass());
            //此处返回的代理和在Main函数中返回的是一样的
            //说明此处代理成功创建
            return proxy;
        }
        //如果拿到的增强方法为空,缓存起来(使用false标记不需要代理)
        this.advisedBeans.put(cacheKey, Boolean.FALSE);
        return bean;
    }
3）开始创建代理对象

重点关注最下面的关键点：proxyFactory.getProxy(getProxyClassLoader())

    //beanClass：目标对象class
    //beanaName
    //specificInterceptors：拦截器里面的拦截方法
    //targetSource:目标资源
    //目标：开始为bean创建代理
    protected Object createProxy(Class beanClass, @Nullable String beanName,
                                 @Nullable Object[] specificInterceptors, TargetSource targetSource) {
        //为true，DefaultListableBeanFactory
        if (this.beanFactory instanceof ConfigurableListableBeanFactory) {
            //给当前的bd设置属性setAttribute("originalTargetClass",bean的class),进入
            AutoProxyUtils.exposeTargetClass((ConfigurableListableBeanFactory) this.beanFactory, beanName, beanClass);
        }
        //创建一个默认的代理工厂DefaultAopProxyFactory，父类无参构造器
        ProxyFactory proxyFactory = new ProxyFactory();


        //proxyFactory通过复制配置进行初始化
        //this为AbstractAutoProxyCreator对象，说明AbstractAutoProxyCreator继承参数实际类型
        proxyFactory.copyFrom(this);
        /**
         * isProxyTargetClass()，默认false
         * true
         *目标对象没有接口(只有实现类) – 使用CGLIB代理机制
         * false
         * 目标对象实现了接口 – 使用JDK代理机制(代理所有实现了的接口)
         */
        if (!proxyFactory.isProxyTargetClass()) {
            //来判断@EnableAspectJAutoProxy注解或者XML的proxyTargetClass参数(true或者false)
            //看看用户有没有指定什么方式生成代理
            // 如果没配置就为空，此处返回false
            if (shouldProxyTargetClass(beanClass, beanName)) {
                proxyFactory.setProxyTargetClass(true);
            } else {
                //评估接口的合理性，一些内部回调接口，比如InitializingBean等，不会被实现jdk代理
                evaluateProxyInterfaces(beanClass, proxyFactory);
            }
        }
        // 把advice(增强)类型的增强包装成advisor类型(强制类型转换)
        Advisor[] advisors = buildAdvisors(beanName, specificInterceptors);
        //加入到代理工厂
        proxyFactory.addAdvisors(advisors);
        //设置要代理的类(目标类)
        proxyFactory.setTargetSource(targetSource);
        //子类实现， 定制代理
        customizeProxyFactory(proxyFactory);
        //用来控制代理工厂被设置后是否还允许修改通知，缺省值为false
        proxyFactory.setFrozen(this.freezeProxy);
        //明明是false?? 此处注意,他是在子类AbstractAdvisorAutoProxyCreator重写了advisorsPreFiltered方法
        if (advisorsPreFiltered()) {
            //设置预过滤
            proxyFactory.setPreFiltered(true);
        }

        //【关键点】通过类加载期获取代理;getProxyClassLoader为默认的类加载器
        return proxyFactory.getProxy(getProxyClassLoader());
    }

进入getProxy

//通过类加载期获取代理
public Object getProxy(@Nullable ClassLoader classLoader) {
   //分别进入createAopProxy 和getProxy
   return createAopProxy().getProxy(classLoader);
}

先看createAopProxy

查看返回jdk代理还是cglib代理

public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
        // isOptimize:是否对代理进行优化
        // isProxyTargetClass:值为true，使用CGLIB代理，默认false
        // hasNoUserSuppliedProxyInterfaces:
        //1、如果长度为0；也就是接口为空，返回false
        //or(或的关系)
        //2、如果接口类型不是SpringProxy类型的；返回flase

        //如果条件不满足；直接走JDK动态代理(return)
        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.");
            }
            // 如果targetClass是接口类，使用JDK来生成Proxy
            //Tips
            //如果目标对象实现了接口，默认情况下会采用JDK动态代理，
            // 但也可以通过配置（proxy-target-class=true）强制使用CGLIB。
            if (targetClass.isInterface() || Proxy.isProxyClass(targetClass)) {
                //jdk
                return new JdkDynamicAopProxy(config);
            }
            //cglib
            return new ObjenesisCglibAopProxy(config);
        } else {
            //jdk
            return new JdkDynamicAopProxy(config);
        }
    }

再看getProxy

    //获取最终的代理对象（由JDK生成；运行时织入）
    @Override
    public Object getProxy(@Nullable ClassLoader classLoader) {
        if (logger.isDebugEnabled()) {
            logger.debug("Creating JDK dynamic proxy: target source is " + this.advised.getTargetSource());
        }
        //获取代理对象需要实现的接口（业务接口和内置接口）
        Class[] proxiedInterfaces = AopProxyUtils.completeProxiedInterfaces(this.advised, true);
        //判断接口中是否重写了equals和hashCode方法
        findDefinedEqualsAndHashCodeMethods(proxiedInterfaces);

        /**
         * 第一个参数是类加载器（目标类）
         * 第二个参数是代理类需要实现的接口，即目标类实现的接口（含系统接口）（数组）
         * 第三个是InvocationHandler，本类实现了此接口
         */
        return Proxy.newProxyInstance(classLoader, proxiedInterfaces, this);
    }

找到了！代理对象在bean初始化阶段装配进了spring

4）代理对象验证

tips：

前面创建完成了代理对象，下面我们看下它调用的时候，是不是走了代理

这是我们一开始的结果，下面我们来再debug到work方法时，点击debug into试试，发现调到哪里去了？？？

爱上源码，重学Spring AOP深入_第8张图片

结论：

没错！代理对象精准的调用了JdkDynamicAopProxy里面的invoke方法

这说明jdk动态代理生效，但是它生成的proxy字节码在jvm里，我们是看不到的，怎么破？

arthas上！

2）Arthas代理类验证

arthas，阿里神器，主页：https://arthas.aliyun.com/zh-cn/

获取之前，我们需要做点小事情，打出我们的 slaver的类路径，让arthas能找到它！

爱上源码，重学Spring AOP深入_第9张图片
源码：

package com.aoptest;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Main {

    public static void main(String[] args) throws InterruptedException {
        ApplicationContext context =
                new ClassPathXmlApplicationContext("classpath*:application-aop.xml");
        Slaver slaver=(Slaver)context.getBean("slaverImpl");
        slaver.work();
        System.out.printf(slaver.getClass().getName());  //打印当前对象的类名称：com.sun.proxy.$Proxy17
        Thread.sleep(Integer.MAX_VALUE); // 必须停留在这里，debug是不行的，arthas会连不上
    }

}

开启arthas：

  • 很简单， java -jar arthas-boot.jar
  • 启动后，在arthas里执行：jad com.sun.proxy.$Proxy17 反编译我们的代理类

注意，jad后面的，换成你上一步控制台打印出来的

见证奇迹的时刻……

找到里面的work方法，结果它长这样……

爱上源码，重学Spring AOP深入_第10张图片

那么，this.h呢？

杀死进程，回到debug模式，看看

爱上源码，重学Spring AOP深入_第11张图片

没错，就是我们的jdk动态代理类！

现在调用关系明确了，接下来，我们就来分析下这个invoke

1.5 代理对象如何调用

1）先看张图

代理对象调用链如下图 (责任链，先有个印象，很长，很长……)

爱上源码，重学Spring AOP深入_第12张图片

2）理解责任链

代码中给大家准备了一个责任链小demo，它就是我们spring aop切面调用链的缩影

spring-aop-test 项目下的 com.spring.test.aop.chain 包。

执行里面的main方法

生活中的例子，类似于：

  • 全公司站成一队，从队首开始签名

    如果先签完再交给下一个，你就是前置拦截。（签名 = 执行切面任务）

    如果先交给下一个，等传回来的时候再签，你就实现了后置，回来的时候再补

  • 一个个传到底后，到达队尾，老板盖章（真正的业务逻辑得到执行）
  • 然后一个个往回传（return），前面没签的那些家伙补上（后置切面任务得到执行）
3）invoke方法源码分析

通过上小节我们知道，代理模式下执行的是以下invoke

org.springframework.aop.framework.JdkDynamicAopProxy#invoke

代码重点关注

// 2.从ProxyFactory（this.advised）中构建拦截器链，包含了目标方法的所有切面方法
List chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass)
        
//责任链开始调用：ReflectiveMethodInvocation.proceed()；重点关注！！！
retVal = invocation.proceed();

责任链构建：chain里面为责任链的具体任务


接下来，我们具体看看责任链具体的处理逻辑


4）AOP核心之责任链


思考：


责任链调用，调用的什么？


责任链目标：


爱上源码，重学Spring AOP深入_第13张图片


AOP责任链调用流程简图


爱上源码，重学Spring AOP深入_第14张图片




注意：上图的颜色区分


黑色：表示正向调用，invoke的时候，在前或后执行自己的切面逻辑，然后推动责任链往下走


红色：表示当前切面任务触发的点


备注：ExposeInvocationInterceptor 是spring帮我们加上做上下文传递的，本图不涉及（它在最前面）




注意，我们的链条如下：


爱上源码，重学Spring AOP深入_第15张图片




调试技巧：


从 ReflectiveMethodInvocation.invoke() 开始，对照上面的责任链嵌套调用图


每次通过debug into 进行查看，每到一环，注意对照图上的节点，看到那个invocation了！




爱上源码，重学Spring AOP深入_第16张图片
案例：第一环，遇proceed，再 debug into


爱上源码，重学Spring AOP深入_第17张图片


依次循环，步步跟进，其乐无穷~~~


2 AOP基础 - 代理模式（助学）


2.1 设计模式之代理


背景
举个例子
假设我们想邀请一位明星,不联系明星
而是联系明星的经纪人,来达到邀请的的目的
明星就是一个目标对象,他只要负责活动中的节目,而其他琐碎的事情就交给他的代理人(经纪人)来解决.
这就是代理思想在现实中的一个例子


什么是代理？


代理(Proxy)是一种设计模式


提供了对目标对象另外的访问方式;即通过代理对象访问目标对象.


这样做的好处是:可以在目标对象实现的基础上,增强额外的功能操作


爱上源码，重学Spring AOP深入_第18张图片
代理模式分类


1、静态代理


2、动态代理


2.2 静态代理模式


静态代理在使用时：


需要定义接口、目标对象与代理对象


重要特点：


静态代理是由程序员创建或工具生成代理类的源码，再编译代理类。


接口


//接口
public interface IStartBusiness {
    //邀请明星唱歌
    void sing();
}



目标对象，实现类


//目标对象，实现类
public class StartBusinessImpl implements IStartBusiness {
    @Override
    public void sing() {
        System.out.println("sing>>>>>>>>>>>>>>>>>>>>>>>>>>>");
    }
}


代理对象,静态代理


package com.spring.test.aop.pattern.proxy.staticproxy;

//代理对象,静态代理
public class AgentProxy implements IStartBusiness {

    //代理类持有一个目标类的对象引用
    private IStartBusiness iStartBusiness;
    //构造注入目标对象
    public AgentProxy(IStartBusiness iStartBusiness) {
        this.iStartBusiness = iStartBusiness;
    }

    @Override
    public void sing() {

        //**********方法前增强****************


        //do something
        //将请求分派给目标类执行；通过注入进入来的目标对象进行访问
        this.iStartBusiness.sing();

        //do after

        //**********方法后增强****************
    }
}



静态代理测试


package com.spring.test.aop.pattern.proxy.staticproxy;

//静态代理测试
public class Test {
    public static void main(String[] args) {
        //目标对象
        IStartBusiness target = new StartBusinessImpl();
        //代理对象,把目标对象传给代理对象,建立代理关系
        IStartBusiness proxy = new AgentProxy(target);
        //调用的时候通过调用代理对象的方法来调用目标对象
        proxy.sing();
    }

}



输出


file


优点：


可以在被代理方法的执行前或后加入别的代码，实现诸如权限及日志的操作。


缺点：


1、如果接口增加一个方法，除了所有实现类需要实现这个方法外，所有代理类也需要实现此方法


​




总结：（记住两点）


1、只需要知道静态代理是在运行前代理类就已经被织入进去了


2、大规模使用静态代理难以维护（增加方法）




有没有其他的方式可以减少代码的维护，那就是动态代理？


2.3 动态代理模式


什么是动态代理？


动态代理类的源码是在程序运行期间由JVM根据反射等机制动态织入的，


所以；不存在代理类的字节码文件，直接进了虚拟机。(但是有办法给抓到他)


JDK中生成代理对象的API最重要类和接口有两个，如下




Proxy


InvocationHandler




1）代理父类Proxy回顾


所在包：java.lang.reflect.Proxy


这是 Java 动态代理机制生成的所有动态代理类的父类，


提供了一组静态方法来为一组接口动态地生成代理类及其对象。 


Proxy类的静态方法（了解）


// 方法 1: 该方法用于获取指定代理对象所关联的调用处理器  
static InvocationHandler getInvocationHandler(Object proxy)   
  
// 方法 2：该方法用于获取关联于指定类装载器和一组接口的动态代理类的类对象  
static Class getProxyClass(ClassLoader loader, Class[] interfaces)   
  
// 方法 3：该方法用于判断指定类对象是否是一个动态代理类  
static boolean isProxyClass(Class cl)   
  
// 方法 4：该方法用于为指定类装载器、一组接口及调用处理器生成动态代理类实例  
static Object newProxyInstance(ClassLoader loader, Class[] interfaces, InvocationHandler h)




tips：重要


重点关注newProxyInstance


这三个参数非常重要


Spring Aop也是使用这个机制




    public static Object newProxyInstance(ClassLoader loader,
                                          Class[] interfaces,
                                          InvocationHandler h)
        throws IllegalArgumentException


注意该方法是在Proxy类中是静态方法,且接收的三个参数依次为:


    

  • ClassLoader loader,:指定当前目标对象使用类加载器 ;负责将类的字节码装载到 Java 虚拟机（JVM）中并为其定义类对象
    • 

  • Class[] interfaces,:目标对象实现的接口的类型,使用泛型方式确认类型
    • 

  • InvocationHandler h:事件处理,执行目标对象的方法时,会触发事件处理器的方法,会把当前执行目标对象的方法作为参数传入
    • 



2）调用处理器接口回顾


java.lang.reflect.InvocationHandler


这是调用处理器接口，它自定义了一个 invoke 方法（只有一个）


用于集中处理在动态代理类对象上的方法调用，通常在该方法中实现对目标类的代理访问。


每次生成动态代理类对象时都要指定一个对应的调用处理器对象。 


爱上源码，重学Spring AOP深入_第19张图片




1、目标对象（委托类）通过jdk的Proxy生成了代理对象、


2、客户端访问代理对象，代理对象通过调用于处理器接口反射调用了目标对象方法




InvocationHandler的核心方法


仅仅一个方法


public interface InvocationHandler {

//第一个参数既是代理类实例
 //第二个参数是被调用的方法对象  
// 第三个方法是调用参数   
Object invoke(Object proxy, Method method, Object[] args) 

}


3）动态代理代码编写


沿用上面的 例子




tips


代理对象不需要实现接口（业务）,但是目标对象一定要实现接口,否则不能用动态代理




接口


目标对象接口


package com.spring.test.aop.pattern.proxy.dynamic;
//接口
public interface IStartBusiness {
    //邀请明星唱歌
    void sing();
}



目标对象


//目标对象
public class StartBusinessImpl implements IStartBusiness {
    @Override
    public void sing() {
        System.out.println("sing>>>>>>>>>>>>>>>>>>>>>>>>>>>");
    }
}


创建动态代理对象


package com.spring.test.aop.pattern.proxy.dynamic;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

 //动态代理实现
public class DynamicProxy implements InvocationHandler {
    // 这个就是我们要代理的真实对象
    private Object obj;

    // 构造方法，给我们要代理的真实对象赋初值
    public DynamicProxy(Object object) {
        this.obj = object;
    }

    //相比静态代理，动态代理减只需要实现一个接口即可完成，而静态代理每次都要实现新加的方法以及维护被代理方法
    
    //第一个参数既是代理类实例
 //第二个参数是被调用的方法对象  
// 第三个方法是调用参数   
    @Override
    public Object invoke(Object object, Method method, Object[] args)
            throws Throwable {

        //********************方法前增强***************************
        // 反射调用目标方法
        return method.invoke(obj, args);
    

        //********************方法后增强***************************
    }

}



测试


package com.spring.test.aop.pattern.proxy.dynamic;

import com.spring.test.aop.pattern.proxy.staticproxy.IStartBusiness;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;

//动态代理测试
//目标：
//1、知道如何创建动态代理
//2、如何调用了invoke方法（拦截方法会用到当前知识点）
public class Test {

    public static void main(String[] args) {
        // 目标对象；要代理的真实对象
        IStartBusiness target = new StartBusinessImpl();
      // 我们要代理哪个真实对象，就将该对象传进去，最后是通过该真实对象来调用其方法的
        InvocationHandler handler = new DynamicProxy(target);
        /*
         * 第一个参数：目标对象加载器
         * 第二个参数：目标对象接口
         * 第三个参数：实现InvocationHandler的代理类
         */

      //生成代理对象
        IStartBusiness iStartBusiness = (IStartBusiness) Proxy.newProxyInstance(target.getClass().getClassLoader(), target
                .getClass().getInterfaces(), handler);
        iStartBusiness.sing();


    }
}




输出


爱上源码，重学Spring AOP深入_第20张图片


总结


1、相比静态代理，动态代理减只需要实现一个接口即可完成，而静态代理每次都要实现新加的方法以及维护被代理方法


2、动态代理是靠Proxy.newProxyInstance() 生成的


3、动态代理在调用（iStartBusiness.sing()）的时候，调用到了 implements InvocationHandler 的invoke


目标明确了：spring的代理就需要我们找到 Proxy.newProxyInstance() 在哪里……


4）动态代理原理（了解）




tips：


涉及JDK字节码，不在spring的源码范围内，感兴趣的同学自己了解一下




参考资料：https://www.baiyp.ren/JAVA%E5...


代理对象内部生成流程调用链，如下图


爱上源码，重学Spring AOP深入_第21张图片


对象生成过程（核心）


爱上源码，重学Spring AOP深入_第22张图片


Proxy.newProxyInstance(classLoader, proxiedInterfaces, this);
进入newProxyInstance方法内部


java.lang.reflect.Proxy#newProxyInstance


重点关注核心方法getProxyClass0


 
//使用jdk代理工厂创建新的代理实例
@CallerSensitive
    public static Object newProxyInstance(ClassLoader loader,
                                          Class[] interfaces,
                                          InvocationHandler h)
        throws IllegalArgumentException
    {
         //判断是否实现InvocationHandler接口，如果此处为空抛出异常
        //当前h非常重要，因为在代理对象调用目标方法的时候，就是通过d的invoke方法反射调用的目标方法
        //稍后会讲解
        Objects.requireNonNull(h);
        //克隆参数传来的 接口
        final Class[] intfs = interfaces.clone();
        //系统内部的安全
        final SecurityManager sm = System.getSecurityManager();
        if (sm != null) {
            //访问权限的验证
            checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
        }

        /*
         *查找或生成指定的代理类；非常重要，重点关注
         */
        Class cl = getProxyClass0(loader, intfs);

        /*
         * Invoke its constructor with the designated invocation handler.
         */
        try {
            if (sm != null) {
                //代理权限的检查（此处是新生产的代理对象c1）
                checkNewProxyPermission(Reflection.getCallerClass(), cl);
            }
            //从生成的代理对象（只是class对象，还不是实例化对象）中取出构造器
            final Constructor cons = cl.getConstructor(constructorParams);
            final InvocationHandler ih = h;
            if (!Modifier.isPublic(cl.getModifiers())) {
                AccessController.doPrivileged(new PrivilegedAction() {
                    public Void run() {
                        cons.setAccessible(true);
                        return null;
                    }
                });
            }
            //使用构造器实例化（实例化对象）
            return cons.newInstance(new Object[]{h});
        } catch (IllegalAccessException|InstantiationException e) {
            throw new InternalError(e.toString(), e);
        } catch (InvocationTargetException e) {
            Throwable t = e.getCause();
            if (t instanceof RuntimeException) {
                throw (RuntimeException) t;
            } else {
                throw new InternalError(t.toString(), t);
            }
        } catch (NoSuchMethodException e) {
            throw new InternalError(e.toString(), e);
        }
    }


进入getProxyClass0


java.lang.reflect.Proxy#getProxyClass0


    private static Class getProxyClass0(ClassLoader loader,
                                           Class... interfaces) {
        //判断接口数组大小，别大于65535，如果大于，提示接口超出限制
        if (interfaces.length > 65535) {
            throw new IllegalArgumentException("interface limit exceeded");
        }

        //通过接口和类加载器创建代理

        //给定的接口存在，这将简单地返回缓存副本；

         //否则，它将通过ProxyClassFactory创建代理类          
        return proxyClassCache.get(loader, interfaces);//也就是查询+创建的过程
    }


继续进入get方法


java.lang.reflect.WeakCache#get


其他不要看


重点关注apply方法


    public V get(K key, P parameter) {
        Objects.requireNonNull(parameter);

        expungeStaleEntries();

        Object cacheKey = CacheKey.valueOf(key, refQueue);

        // lazily install the 2nd level valuesMap for the particular cacheKey
        ConcurrentMap> valuesMap = map.get(cacheKey);
        if (valuesMap == null) {
            ConcurrentMap> oldValuesMap
                = map.putIfAbsent(cacheKey,
                                  valuesMap = new ConcurrentHashMap<>());
            if (oldValuesMap != null) {
                valuesMap = oldValuesMap;
            }
        }

        // create subKey and retrieve the possible Supplier stored by that
        // subKey from valuesMap
        Object subKey = Objects.requireNonNull(subKeyFactory.apply(key, parameter));
        Supplier supplier = valuesMap.get(subKey);
        Factory factory = null;

        while (true) {
            if (supplier != null) {
                // supplier might be a Factory or a CacheValue instance
                V value = supplier.get();
                if (value != null) {
                    return value;
                }
            }
            // else no supplier in cache
            // or a supplier that returned null (could be a cleared CacheValue
            // or a Factory that wasn't successful in installing the CacheValue)

            // lazily construct a Factory
            if (factory == null) {
                factory = new Factory(key, parameter, subKey, valuesMap);
            }

            if (supplier == null) {
                supplier = valuesMap.putIfAbsent(subKey, factory);
                if (supplier == null) {
                    // successfully installed Factory
                    supplier = factory;
                }
                // else retry with winning supplier
            } else {
                if (valuesMap.replace(subKey, supplier, factory)) {
                    // successfully replaced
                    // cleared CacheEntry / unsuccessful Factory
                    // with our Factory
                    supplier = factory;
                } else {
                    // retry with current supplier
                    supplier = valuesMap.get(subKey);
                }
            }
        }
    }


进入apply方法（内部类）


java.lang.reflect.Proxy.ProxyClassFactory#apply


 //目的
//1、判断；比如当前的class是否对加载器可见；访问权限。是否public的
//2、生成class字节码文件
//3、调用本地方法；通过class字节码文件生成class对象

@Override
        public Class apply(ClassLoader loader, Class[] interfaces) {

            Map, Boolean> interfaceSet = new IdentityHashMap<>(interfaces.length);
            for (Class intf : interfaces) {
                /*
                 * Verify that the class loader resolves the name of this
                 * interface to the same Class object.
                 */
                Class interfaceClass = null;
                try {
                    //当前的class是否对加载器可见
                    interfaceClass = Class.forName(intf.getName(), false, loader);
                } catch (ClassNotFoundException e) {
                }
                if (interfaceClass != intf) {
                    throw new IllegalArgumentException(
                        intf + " is not visible from class loader");
                }
                /*
                 * 验证类对象是否实际表示接口
                 *  
                 */
                if (!interfaceClass.isInterface()) {
                    throw new IllegalArgumentException(
                        interfaceClass.getName() + " is not an interface");
                }
                /*
                 * 验证此接口不是重复的。
                 */
                if (interfaceSet.put(interfaceClass, Boolean.TRUE) != null) {
                    throw new IllegalArgumentException(
                        "repeated interface: " + interfaceClass.getName());
                }
            }

            String proxyPkg = null;     // package to define proxy class in
            int accessFlags = Modifier.PUBLIC | Modifier.FINAL;

            /*
             * Record the package of a non-public proxy interface so that the
             * proxy class will be defined in the same package.  Verify that
             * all non-public proxy interfaces are in the same package.
             */
            for (Class intf : interfaces) {
                int flags = intf.getModifiers();
          
                if (!Modifier.isPublic(flags)) {
                    accessFlags = Modifier.FINAL;
                    String name = intf.getName();
                    int n = name.lastIndexOf('.');
                    String pkg = ((n == -1) ? "" : name.substring(0, n + 1));
                    if (proxyPkg == null) {
                        proxyPkg = pkg;
                    } else if (!pkg.equals(proxyPkg)) {
                              //是否public的
                        throw new IllegalArgumentException(
                            "non-public interfaces from different packages");
                    }
                }
            }

            if (proxyPkg == null) {
                // 如果没有非公共代理接口，请使用com.sun.proxy
                proxyPkg = ReflectUtil.PROXY_PACKAGE + ".";
            }

            /*
             * 这里需要注意下.他对应的是代理对象proxy后的数值；比如$proxy100
             *这里的100；就是此处原子生成
             */
            long num = nextUniqueNumber.getAndIncrement();
            //$proxy100；非常熟悉了；通过断点查看代理对象看到的，就是从这里生成的
            //proxyClassNamePrefix这个前缀就是 $
            //这个proxyPkg就是com.sun.proxy
            String proxyName = proxyPkg + proxyClassNamePrefix + num;

            /*
             *使用ProxyGenerator里面的工具类，帮助我们生成代理类的class内容
             注意。此处存储到byte数组；目前还不是class对象
             */
            byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
                proxyName, interfaces, accessFlags);
            try {
                //此处才是真正的class对象（注意；虽然是对象；但是还没有实例化）
                return defineClass0(loader, proxyName,
                                    proxyClassFile, 0, proxyClassFile.length);
            } catch (ClassFormatError e) {
                /*
                 * A ClassFormatError here means that (barring bugs in the
                 * proxy class generation code) there was some other
                 * invalid aspect of the arguments supplied to the proxy
                 * class creation (such as virtual machine limitations
                 * exceeded).
                 */
                throw new IllegalArgumentException(e.toString());
            }
        }
    }




核心代码参看以上注释



断点查看slaver.work()


        ApplicationContext context =
                new ClassPathXmlApplicationContext("classpath*:application-aop.xml");
        Slaver slaver = (Slaver) context.getBean("slaverImpl");
        //使用代理调用了JdkDynamicAopProxy.invoke
        slaver.work();
        System.out.println("over>>>>>>>>>>");



注意里面的 $proxy17,全部都是在上面生成的


爱上源码，重学Spring AOP深入_第23张图片


最终这个才是实例化的对象（如上）




如果本文对您有帮助，欢迎关注和点赞`，您的支持是我坚持创作的动力。


转载请注明出处！


























你可能感兴趣的:(java后端springaop)






    

  • Java中的服务端点响应缓存：Spring Cache抽象
微赚淘客机器人开发者联盟@聚娃科技
java缓存spring

    Java中的服务端点响应缓存：SpringCache抽象大家好，我是微赚淘客返利系统3.0的小编，是个冬天不穿秋裤，天冷也要风度的程序猿！在Java后端服务开发中，缓存是一个重要的性能优化手段。Spring框架提供了一个强大的缓存抽象，允许开发者以统一的方式使用不同的缓存技术。本文将介绍如何在Java应用中使用SpringCache抽象来实现服务端点的响应缓存。响应缓存的重要性响应缓存在服务端点中
    

    • 

  • 月度总结 | 2022年03月 | 考研与就业的抉择 | 确定未来走大数据开发路线
「已注销」
个人总结hadoop

    一、时间线梳理3月3日，寻找到同专业的就业伙伴3月5日，着手准备Java八股文，决定先走Java后端路线3月8月，申请到了校图书馆的考研专座，决定暂时放弃就业，先准备考研，买了数学和408的资料书3月9日-3月13日，因疫情原因，宿舍区暂封，这段时间在准备考研，发现内容特别多3月13日-3月19日，大部分时间在刷Hadoop、Zookeeper、Kafka的视频，同时在准备实习的项目3月20日，退
    

    • 

  • Java后端面试高频问题：HashMap的底层原理
2401_84408267
程序员java面试开发语言

    ④如果该位置不为null,则判断key是否一样(hashCode和equals)，如果一样则直接覆盖value⑤如果key不一样，则判断该元素是否为红黑树的节点，如果是，则直接在红黑树中插入键值对⑥如果不是红黑树的节点，则就是链表，遍历这个链表执行插入操作，如果遍历过程中若发现key已存在，直接覆盖value即可。如果链表的长度大于等于8且数组中元素数量大于等于阈值64，则将链表转化为红黑树，（先
    

    • 

  • 最新出炉的java后端学习路线
java进阶程序员xx

    在写这个文章之前，我花了点时间，自己臆想了一个电商系统，基本上算是麻雀虽小五脏俱全，我今天就用它开刀，一步步剖析，我会讲一下我们可能会接触的技术栈可能不全，但是够用，最后给个学习路线。Tip：请多欣赏一会，每个点看一下，看看什么地方是你接触过的，什么技术栈是你不太熟悉的，我觉得还算是比较全的，有什么建议也可以留言给我。不知道大家都看了一下没，现在我们就要庖丁解牛了，我从上到下依次分析。前端你可能会
    

    • 

  • 深入浅出：使用Spring Boot实现AOP切面编程
一休哥助手
javaspringboot后端java

    目录引言AOP概述AOP的定义与核心概念AOP的优势SpringBoot中的AOP实现SpringAOP与AspectJ依赖配置AOP的工作原理
    

    • 

  • java 实现前后端分离_详解前后端分离之Java后端
bfecoder
java实现前后端分离

    前后端分离的思想由来已久，不妨尝试一下，从上手开始，先把代码写出来再究细节。前言以前服务端为什么能识别用户呢？对，是session，每个session都存在服务端，浏览器每次请求都带着sessionId(就是一个字符串)，于是服务器根据这个sessionId就知道是哪个用户了。那么问题来了，用户很多时，服务器压力很大，如果采用分布式存储session，又可能会出现不同步问题，那么前后端分离就很好的
    

    • 

  • java后端如何发送http请求
Lzehui
javahttp开发语言

    用java后端发送请求需要用到的一个工具包为HttpClient。HttpClient是Apache的一个子项目，是高效的、功能丰富的支持HTTP协议的客户端编程工具包。引入依赖org.apache.httpcomponentshttpclient4.5.13发送GET请求后面附有代码示例第一步：用HttpClients的createDefault（）方法，创建httpclient对象，用于后续发
    

    • 

  • java后端处理前端上传二进制流excel文件
撸不动码的猴子
javajavapoiexcelvue

    最近项目中有需要上传excel文档,后端解析入库,项目技术选型springcloud+vue+postgres.后台接收二进制流,使用@RequestParam(value=“file”)MultipartFilefile去接收,然后就是引入poi依赖,进行操作.poi就是对office文件处理的依赖jar包,加入maven加入依赖后,对其进行操作.我把它提取成方法,尽量避免在controller
    

    • 

  • java后端未来学习之路
命z
javajava后端学习

    最近找到了一篇文章，感觉是自己可以借鉴的，具体内容如下：首先，我个人比较推崇的学习方法是：先学java前端，也就是HTML，css，js，因为学习java以后肯定是往javaee方向发展的，学习完前端，在学习后端很多东西比计较容易理解！其中J2SE是关键，如果学好了javase部分，基础扎实了，后面进阶学习也比较轻松！补充说明一下：我觉得学习java比较合适的方法是先把所有的知识点过一遍，然后把所
    

    • 

  • AOP面向切面编程
科马
javaspringjava后端

    AOP面向切面编程如何理解面向切面编程举例理解：核心概念：SpringAOP两种配置风格基于注解的`@AspectJ`风格基于XML的Schema风格代理机制JDK动态代理CGLIB代理编程方式创建代理配置AspectJ加载时织入如何理解面向切面编程面向切面编程（Aspect-OrientedProgramming，简称AOP）是一种编程范式，它允许开发者将横切关注点（如日志记录、事务管理等）与业
    

    • 

  • Spring Aop
GG编程
springjava后端

    1.基本概念：SpringAOP（面向切面编程）是Spring框架的一个重要功能，它允许在Spring应用程序中对横切关注点（Cross-CuttingConcerns）进行模块化。横切关注点是指那些影响多个类或模块的功能，比如日志记录、事务管理、安全性和异常处理等。AOP是面向切面编程，它是对某一类事情的集中处理，它是一种思想，而SpringAOP是对这个思想的具体实现2.关键概念:(1).As
    

    • 

  • 干货含源码！如何用Java后端操作Docker（命令行篇）
watermelo37
Docker与云原生JavaEE/SpringBootjava开发语言docker云原生容器devopsspringboot

    目录干货含源码！如何用Java后端操作Docker（命令行篇）一、为什么要用后端程序操作Docker二、安装Docker1、安装Docker2、启动Docker三、使用Java后端操作docker1、构建docker镜像并生成容器2、执行完毕后删除容器和镜像3、在此基础上开发其他功能四、总结作者：watermelo37涉及领域：Vue、SpingBoot、Docker、LLM、python等---
    

    • 

  • MyBatis框架与spring框架整合
李恩11
mybatisspringjava

    MyBatis—Spring项目目前大部分的Java互联网项目，都是用SpringMVC+Spring+MyBatis搭建平台的。使用SpringIoC可以有效的管理各类的Java资源，达到即插即拔的功能；通过SpringAOP框架，数据库事务可以委托给Spring管理，消除很大一部分的事务代码，配合MyBatis的高灵活、可配置、可优化SQL等特性，完全可以构建高性能的大型网站。毫无疑问，MyB
    

    • 

  • SpringBoot配置Java后端服务器
Dream-kid
javaspringbootspring

    前言本文阅读提醒:读者需要了解spring框架知识MyBatis框架知识以及springBoot框架知识.其中涉及到:注册与配置拦截器,MyBatis数据处理,springWeb知识,spring注解标签等,springBoot异常统一处理以及springBoot配置服务器目录前言SpringBoot服务器搭建服务器与数据库链接SpringBoot统一异常处理拦截器注册与搭建编写拦截器注册拦截器服
    

    • 

  • AOP(面向切面编程)
买完可乐
spring

    1.AOP是什么AOP是面向切面编程，能够让我们在不影响原有功能的前提下,为软件横向扩展功能2.搭建SpringAOP使用aspect实现aop的基本步骤：1.新建maven项目2.加入依赖（1）spring依赖（2）aspectj依赖（3）junit单元测试3.创建目标类:接口和他的实现类。要做的是给类中的方法增加功能4.创建切面类:普通类（1）在类的上面加入@Aspect（2）在类中定义方法，
    

    • 

  • 【spring】Spring的aop
闲着无聊整些资料
Springspringjava后端

    之前的文章中我们介绍了Spring的控制反转和依赖注入，今天来详细说说Spring的aop。aop（AspectOrientedProgramming）即面向切面编程，它是Spring提出的一种思想，是为了在不修改源代码的基础上对原代码进行增强，Springaop是aop思想的实现。我们知道java一贯接收的是OOP（ObjectOrientedProgramming，面向对象开发）思想，在开发过
    

    • 

  • Spring——AOP面向切面编程&SpringAOP与AspectJ比较
七海健人
Spring框架springjava

    最近跟着源码研究了下Spring使用三级缓存处理循环依赖的原理，里面涉及到SpringAOP的概念；本篇介绍AOP相关的知识点，AOP下的概念名词比较多，尽量使用通俗的概念来逐个解释，内容包括：对AOP（面向切面编程）的理解、AOP下的名词概念、SpringAOP与AspectJ的比较等；这部分知识对于学习Spring框架或者面试，都非常重要，需要掌握；1.到底什么是AOP（面向切面编程）？乍一看
    

    • 

  • 适合大学生的java后台学习方法
万年星光

    原文转载https://blog.csdn.net/m0_37907797/article/details/115548456?utm_source=app&app_version=4.5.8姓名：魏子勋学号20009101910学院：竹园三号书院【嵌牛导读】本文主要介绍了对于大学生来说适合的java学习路径【嵌牛鼻子】java后端学习【嵌牛提问】如何快速高效的学java后台开发【嵌牛正文】一、J
    

    • 

  • 【面试题】JavaScript 中 try
2401_84438488
javascript开发语言ecmascript

    地址：前端面试题库web前端面试题库VSjava后端面试题库大全作为一位Web前端工程师，JavaScript中的try...catch是我们常用的特性之一。try...catch可以捕获代码中的异常并防止应用程序崩溃。但是try...catch不仅仅是简单地捕获异常。本文我将分享10个有用的try...catch使用技巧，让你在处理异常时更加得心应手。1.捕获所有异常如果你想捕获代码中所有可能的
    

    • 

  • QPS提升10倍怎么设计-JAVA后端经常用到的技术
九张算数
java开发语言

    如果要将系统的QPS（QueriesPerSecond，每秒查询率）提升10倍，可以从以下几个方面进行设计：一、硬件层面增加服务器资源可以增加服务器的数量，通过负载均衡将流量分发到不同的服务器上，从而提高系统的整体处理能力。例如，使用分布式服务器集群，将请求均匀地分配到各个节点上，避免单个服务器负载过高。升级服务器的硬件配置，如提高CPU性能、增加内存容量、使用更快的存储设备等。例如，采用多核处理
    

    • 

  • SpringAOP使用
zxcvbnmzsedr

    问题描述面向对象设计中有一个弊端，当需要为多个不具有继承关系的对象引入同一个公共行为时，例如日志、安全检测等，需要在每个类中都要去引用一个公共行为，这样的话会产生大量的重复代码。image记录操作日志，需要在每个方法里都要去进行相同的操作。这只是记录操作，加入要去进行统计方法执行的时间，或者对这个方法进行权限的校验，会产生更多的冗余代码。而且这些公共操作和真正的业务交织在一起，会使代码的可读性直线
    

    • 

  • 初识Mybatis框架
澄岚明雪
mybatis

    什么是框架框架就是对技术的封装，将基础的技术进行封装，让程序员可以快速的使用，提高开发效率JAVA后端框架mybatis对jdbc进行封装spring对整个java后端架构进行管理的springweb对web层（servlet）进行封装springboot对spring框架的搭建进行封装Linux操作系统mysqlredisdocker开发好的项目部署到linux环境mybatis背景介绍：myb
    

    • 

  • 秋招Java后端开发——非关系型数据库篇（Redis）
番茄炒西红柿炒蛋
秋招Java后端数据库数据库nosqlredis

    一、非关系型数据库1.主要针对的是键值、文档以及图形类型数据存储。2.特点：特点说明灵活的数据模型支持多种数据模型（文档、键值、列族、图），无需预定义固定的表结构，能够处理各种类型的数据。高扩展性设计为水平扩展，能够轻松地通过增加更多节点来处理大量的数据和高并发请求。高性能通过优化特定类型的查询和数据操作，通常比关系型数据库在大规模数据处理时表现更好。分布式架构天生支持分布式存储和计算，能够跨多个
    

    • 

  • 《Java 后端面试经》Linux 篇
ReadThroughLife
Linux#Java后端面试经linuxjava面试

    《Java后端面试经》专栏文章索引：《Java后端面试经》Java基础篇《Java后端面试经》JavaEE篇《Java后端面试经》数据库篇《Java后端面试经》多线程与并发编程篇《Java后端面试经》JVM篇《Java后端面试经》操作系统篇《Java后端面试经》Linux篇《Java后端面试经》设计模式篇《Java后端面试经》计算机网络篇《Java后端面试经》微服务篇《Java后端面试经》Linu
    

    • 

  • java后端都要学那些知识
程序员牛马家
有关计算机就业的自我观点java

    java后端应该学习那些知识一、引言Java后端的重要性：介绍Java作为后端开发语言的广泛应用，包括企业级应用、大数据处理、云计算等领域。学习Java后端的意义：阐述掌握Java后端开发技能对于职业发展的重要性，以及它如何帮助解决实际问题。二、Java基础数据类型与变量：介绍Java的基本数据类型、变量声明与初始化。控制结构：详细讲解if-else、switch、for、while等控制语句的用
    

    • 

  • 网页端监听用户登陆状态
小可乐-我一直在
bootspringbootactivemqredis

    项目结构：pc管理端，pc机构端，vue，springboot，mysql，activeMq，redis项目需求：需要记录用户登陆时间，登出时间，登陆时长注：一般用户不会走退出登录操作，会直接关闭页面，或者关闭浏览器人员：java后端（不懂前端）解决方案：假设pc管理端admin账户ID为1用户标识为1-1(管理端-用户ID)步骤一：先生成用户身份信息1、用户登陆后将token存进redis，数据
    

    • 

  • wueasy基础平台1.3.0版本发布
fallsea

    1.3.0版本发布wueasy是一个java后端的分布式快速开发平台（框架），主要用于提供后端接口的研发，提供简单、高效、安全、稳定的基础平台。使用自动生成代码工具，可以更便捷的开发。底层基于SpringBoot和RPC实现的一个分布式框架。1.高效开发.他使开发更简洁、更高效新的开发模式，开发一个业务功能已最新的代码来实现，不需要太多的代码和配置，使开发更简洁、高效。提供接口自动生成工具，减少重
    

    • 

  • 程序员开发技术整理
laizhixue
学习前端框架

    前端技术：vue-前端框架element-前端框架bootstrap-前端框架echarts-图标组件C#后端技术：webservice：soap架构：简单的通信协议，用于服务通信ORM框架：对象关系映射，如EF：对象实体模型，是ado.net中的应用技术soap服务通讯：xml通讯ado.net：OAuth2:登录授权认证：Token认证：JWT：jsonwebtokenJava后端技术：便捷工
    

    • 

  • java后端工程师八股文合集
吹林
springcloudeurekajavajava-eespringboot

    1、SQL调优的基本步骤如下：确认性能瓶颈：首先要确定数据库中哪些查询是慢的，哪些查询最需要优化。可以通过监控数据库的CPU、磁盘I/O、网络I/O、缓存等指标来确定性能瓶颈。优化查询语句：如果查询语句本身存在问题，例如使用了不必要的子查询、重复的连接操作等，就需要对查询语句进行优化。优化索引：索引是提高查询性能的关键因素之一。可以通过创建、修改、删除索引来优化查询性能。优化数据结构：如果数据库中
    

    • 

  • JdkDynamicAopProxy学习
weixin_44877172
Spring学习javaspring

    简介JdkDynamicAopProxy#invoke是SpringAOP（面向切面编程）框架中用于动态代理的核心方法之一。这个方法是在使用JDK动态代理时，通过JdkDynamicAopProxy类创建的代理对象上调用目标方法时，被自动调用的。以下是该方法的解析：方法签名首先，我们先看一下invoke方法的签名：publicObjectinvoke(Objectproxy,Methodmetho
    

    • 

  • java类加载顺序
3213213333332132
java

    package com.demo;
/**
* @Description 类加载顺序
* @author FuJianyong
* 2015-2-6上午11:21:37
*/
public class ClassLoaderSequence {
String s1 = "成员属性";
static String s2 = "
    

    • 

  • Hibernate与mybitas的比较
BlueSkator
sqlHibernate框架ibatisorm

    第一章     Hibernate与MyBatis
Hibernate 是当前最流行的O/R mapping框架，它出身于sf.net，现在已经成为Jboss的一部分。 Mybatis 是另外一种优秀的O/R mapping框架。目前属于apache的一个子项目。
MyBatis 参考资料官网：http:
    

    • 

  • php多维数组排序以及实际工作中的应用
dcj3sjt126com
PHPusortuasort

    自定义排序函数返回false或负数意味着第一个参数应该排在第二个参数的前面, 正数或true反之, 0相等usort不保存键名uasort 键名会保存下来uksort 排序是对键名进行的
<!doctype html>
<html lang="en">
<head>
<meta charset="utf-8&q
    

    • 

  • DOM改变字体大小
周华华
前端

    <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml&q
    

    • 

  • c3p0的配置
g21121
c3p0

    c3p0是一个开源的JDBC连接池，它实现了数据源和JNDI绑定，支持JDBC3规范和JDBC2的标准扩展。c3p0的下载地址是：http://sourceforge.net/projects/c3p0/这里可以下载到c3p0最新版本。
以在spring中配置dataSource为例：
<!-- spring加载资源文件 -->
<bean name="prope
    

    • 

  • Java获取工程路径的几种方法
510888780
java

    第一种：
File f = new File(this.getClass().getResource("/").getPath());
System.out.println(f);
结果:
C:\Documents%20and%20Settings\Administrator\workspace\projectName\bin
获取当前类的所在工程路径;
如果不加“
    

    • 

  • 在类Unix系统下实现SSH免密码登录服务器
Harry642
免密ssh

    1.客户机
    (1)执行ssh-keygen -t rsa -C "[email protected]"生成公钥，xxx为自定义大email地址
    (2)执行scp ~/.ssh/id_rsa.pub root@xxxxxxxxx:/tmp将公钥拷贝到服务器上，xxx为服务器地址
    (3)执行cat
    

    • 

  • Java新手入门的30个基本概念一
aijuans
javajava 入门新手

    在我们学习Java的过程中,掌握其中的基本概念对我们的学习无论是J2SE,J2EE,J2ME都是很重要的,J2SE是Java的基础,所以有必要对其中的基本概念做以归纳,以便大家在以后的学习过程中更好的理解java的精髓,在此我总结了30条基本的概念。　　Java概述:　　目前Java主要应用于中间件的开发(middleware)---处理客户机于服务器之间的通信技术,早期的实践证明,Java不适合
    

    • 

  • Memcached for windows 简单介绍
antlove
javaWebwindowscachememcached

    1. 安装memcached server
a. 下载memcached-1.2.6-win32-bin.zip
b. 解压缩，dos 窗口切换到 memcached.exe所在目录，运行memcached.exe -d install
c.启动memcached Server,直接在dos窗口键入 net start "memcached Server&quo
    

    • 

  • 数据库对象的视图和索引
百合不是茶
索引oeacle数据库视图

     
视图
 
  视图是从一个表或视图导出的表，也可以是从多个表或视图导出的表。视图是一个虚表，数据库不对视图所对应的数据进行实际存储，只存储视图的定义，对视图的数据进行操作时,只能将字段定义为视图,不能将具体的数据定义为视图
 
    为什么oracle需要视图;
   &
    

    • 

  • Mockito(一) --入门篇
bijian1013
持续集成mockito单元测试

            Mockito是一个针对Java的mocking框架，它与EasyMock和jMock很相似，但是通过在执行后校验什么已经被调用，它消除了对期望 行为（expectations）的需要。其它的mocking库需要你在执行前记录期望行为（expectations），而这导致了丑陋的初始化代码。
 &nb
    

    • 

  • 精通Oracle10编程SQL(5)SQL函数
bijian1013
oracle数据库plsql

    /*
* SQL函数
*/
--数字函数
--ABS(n):返回数字n的绝对值
declare
v_abs number(6,2);
begin
v_abs:=abs(&no);
dbms_output.put_line('绝对值：'||v_abs);
end;
--ACOS(n):返回数字n的反余弦值，输入值的范围是-1~1，输出值的单位为弧度
    

    • 

  • 【Log4j一】Log4j总体介绍
bit1129
log4j

    Log4j组件：Logger、Appender、Layout
 
Log4j核心包含三个组件：logger、appender和layout。这三个组件协作提供日志功能：
日志的输出目标
日志的输出格式
日志的输出级别(是否抑制日志的输出)
 logger继承特性
A logger is said to be an ancestor of anothe
    

    • 

  • Java IO笔记
白糖_
java

     public static void main(String[] args) throws IOException {
//输入流
InputStream in = Test.class.getResourceAsStream("/test");
InputStreamReader isr = new InputStreamReader(in);
Bu
    

    • 

  • Docker 监控
ronin47
docker监控

            
目前项目内部署了docker，于是涉及到关于监控的事情，参考一些经典实例以及一些自己的想法，总结一下思路。 1、关于监控的内容 监控宿主机本身
监控宿主机本身还是比较简单的，同其他服务器监控类似，对cpu、network、io、disk等做通用的检查，这里不再细说。
额外的，因为是docker的
    

    • 

  • java-顺时针打印图形
bylijinnan
java

    一个画图程序 要求打印出：
1.int i=5;
2.1 2 3 4 5
3.16 17 18 19 6
4.15 24 25 20 7
5.14 23 22 21 8
6.13 12 11 10 9
7.
8.int i=6
9.1 2 3 4 5 6
10.20 21 22 23 24 7
11.19
    

    • 

  • 关于iReport汉化版强制使用英文的配置方法
Kai_Ge
iReport汉化英文版

    对于那些具有强迫症的工程师来说，软件汉化固然好用，但是汉化不完整却极为头疼，本方法针对iReport汉化不完整的情况，强制使用英文版，方法如下：
在 iReport 安装路径下的 etc/ireport.conf 里增加红色部分启动参数，即可变为英文版。  
# ${HOME} will be replaced by user home directory accordin
    

    • 

  • [并行计算]论宇宙的可计算性
comsci
并行计算

    
      现在我们知道,一个涡旋系统具有并行计算能力.按照自然运动理论,这个系统也同时具有存储能力,同时具备计算和存储能力的系统,在某种条件下一般都会产生意识......
      那么,这种概念让我们推论出一个结论
    &nb
    

    • 

  • 用OpenGL实现无限循环的coverflow
dai_lm
androidcoverflow

    网上找了很久，都是用Gallery实现的，效果不是很满意，结果发现这个用OpenGL实现的，稍微修改了一下源码，实现了无限循环功能
源码地址：
https://github.com/jackfengji/glcoverflow
public class CoverFlowOpenGL extends GLSurfaceView implements
GLSurfaceV
    

    • 

  • JAVA数据计算的几个解决方案1
datamachine
javaHibernate计算

    老大丢过来的软件跑了10天，摸到点门道，正好跟以前攒的私房有关联，整理存档。
-----------------------------华丽的分割线-------------------------------------
    数据计算层是指介于数据存储和应用程序之间，负责计算数据存储层的数据，并将计算结果返回应用程序的层次。J
 &nbs
    

    • 

  • 简单的用户授权系统,利用给user表添加一个字段标识管理员的方式
dcj3sjt126com
yii

    怎么创建一个简单的(非 RBAC)用户授权系统
通过查看论坛，我发现这是一个常见的问题，所以我决定写这篇文章。
本文只包括授权系统.假设你已经知道怎么创建身份验证系统(登录)。 数据库
首先在 user 表创建一个新的字段(integer 类型),字段名 'accessLevel',它定义了用户的访问权限 扩展 CWebUser 类
在配置文件(一般为 protecte
    

    • 

  • 未选之路
dcj3sjt126com
诗

    作者:罗伯特*费罗斯特
 
黄色的树林里分出两条路,
可惜我不能同时去涉足,
我在那路口久久伫立,
我向着一条路极目望去,
直到它消失在丛林深处.
 
但我却选了另外一条路,
它荒草萋萋,十分幽寂;
显得更诱人,更美丽,
虽然在这两条小路上,
都很少留下旅人的足迹.
 
那天清晨落叶满地,
两条路都未见脚印痕迹.
呵,留下一条路等改日再
    

    • 

  • Java处理15位身份证变18位
蕃薯耀
18位身份证变15位15位身份证变18位身份证转换

     
15位身份证变18位，18位身份证变15位
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
蕃薯耀 201
    

    • 

  • SpringMVC4零配置--应用上下文配置【AppConfig】
hanqunfeng
springmvc4

    从spring3.0开始，Spring将JavaConfig整合到核心模块，普通的POJO只需要标注@Configuration注解，就可以成为spring配置类，并通过在方法上标注@Bean注解的方式注入bean。
 
Xml配置和Java类配置对比如下：
applicationContext-AppConfig.xml
 
<!-- 激活自动代理功能 参看：
    

    • 

  • Android中webview跟JAVASCRIPT中的交互
jackyrong
JavaScripthtmlandroid脚本

      在android的应用程序中,可以直接调用webview中的javascript代码,而webview中的javascript代码,也可以去调用ANDROID应用程序(也就是JAVA部分的代码).下面举例说明之:
1 JAVASCRIPT脚本调用android程序
   要在webview中,调用addJavascriptInterface(OBJ,int
    

    • 

  • 8个最佳Web开发资源推荐
lampcy
编程Web程序员

    Web开发对程序员来说是一项较为复杂的工作，程序员需要快速地满足用户需求。如今很多的在线资源可以给程序员提供帮助，比如指导手册、在线课程和一些参考资料，而且这些资源基本都是免费和适合初学者的。无论你是需要选择一门新的编程语言，或是了解最新的标准，还是需要从其他地方找到一些灵感，我们这里为你整理了一些很好的Web开发资源，帮助你更成功地进行Web开发。
这里列出10个最佳Web开发资源，它们都是受
    

    • 

  • 架构师之面试------jdk的hashMap实现
nannan408
HashMap

    1.前言。
  如题。
2.详述。
  (1)hashMap算法就是数组链表。数组存放的元素是键值对。jdk通过移位算法（其实也就是简单的加乘算法），如下代码来生成数组下标(生成后indexFor一下就成下标了）。
static int hash(int h)
{
h ^= (h >>> 20) ^ (h >>>
    

    • 

  • html禁止清除input文本输入缓存
Rainbow702
html缓存input输入框change

    多数浏览器默认会缓存input的值，只有使用ctl+F5强制刷新的才可以清除缓存记录。
如果不想让浏览器缓存input的值，有2种方法：
方法一： 在不想使用缓存的input中添加 autocomplete="off"; 
<input type="text" autocomplete="off" n
    

    • 

  • POJO和JavaBean的区别和联系
tjmljw
POJOjava beans

    POJO 和JavaBean是我们常见的两个关键字，一般容易混淆，POJO全称是Plain Ordinary Java Object / Pure Old Java Object，中文可以翻译成：普通Java类，具有一部分getter/setter方法的那种类就可以称作POJO，但是JavaBean则比 POJO复杂很多， Java Bean 是可复用的组件，对 Java Bean 并没有严格的规
    

    • 

  • java中单例的五种写法
liuxiaoling
java单例

    /**
* 单例模式的五种写法：
* 1、懒汉
* 2、恶汉
* 3、静态内部类
* 4、枚举
* 5、双重校验锁
*/
/**
* 五、 双重校验锁，在当前的内存模型中无效
*/
class LockSingleton
{
private volatile static LockSingleton singleton;
pri
    

    •