2020-11-22

最新推荐文章于 2023-05-18 10:09:03 发布

TuxedoLinux

最新推荐文章于 2023-05-18 10:09:03 发布

阅读量79

点赞数

本文链接：https://blog.csdn.net/tuxedolinux/article/details/109953104

版权

新线程创建

当程序调用start()方法时，会创建一个新线程，然后执行run()方法。但是如果我们直接调用run()方法，则不会创建新的线程，run()方法将作为当前调用线程本身的常规方法调用执行，并且不会发生多线程。

Throw：

作用在方法内，表示抛出具体异常，由方法体内的语句处理。
具体向外抛出的动作，所以它抛出的是一个异常实体类。若执行了Throw一定是抛出了某种异常。

Throws：

作用在方法的声明上，表示如果抛出异常，则由该方法的调用者来进行异常处理。
主要的声明这个方法会抛出会抛出某种类型的异常，让它的使用者知道捕获异常的类型。
出现异常是一种可能性，但不一定会发生异常

作者：夏昊
链接：https://www.zhihu.com/question/24863332/answer/863736101
来源：知乎
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

先来看一个简单的小例子，体会一下AOP能解决什么问题：

如果我们要在A,B,C三个类的do方法中都加入日志功能

定义一个日志类Record，加日志的方法：addRecord

Public class A{
 Public void do(){
 …
 Record.addRecord();//添加日志
 }
}

Public class B{
 Public void do(){
 …
 Record.addRecord();//添加日志
 }
}
Public class C{
 Public void do(){
 …
 Record.addRecord();//添加日志
 }
}

这样做可以解决问题，但是总感觉有些别扭，每个类的do方法中都调用了添加日志的方法，添加日志的方法不是我们的核心业务，我们却要去处理它

随着系统越来越完善，类似这样的非核心业务也会越来越多，比如权限，异常处理，性能监控等

这样的功能出现在很多类的很多方法中干扰了我们的核心业务代码，怎么解决呢？AOP就是为此而生：

看看AOP是如何解决的？

从上图可以看出对于日志记录，性能监控，异常处理这样的非核心功能，单独被抽取出来，与业务代码分离，横切在核心业务代码之上

这就是我们通常所说的面向切面编程(AOP),通过一个例子看看他是如何实现的

创建一个UserDao类：

@Repository
public class UserDao {
 public void addUser(){
 System.out.println("添加用户");
 }
 public void updateUser(){
 System.out.println("修改用户");
 }
 public void deleteUser(){
 System.out.println("删除用户");
 }
}

创建一个切面类:

@Aspect
public class MyAspectLog {
    /**
     * 方法执行完后执行的方法
     */
@After(value="execution(* cn.xh.dao.UserDao.addUser(..))")
    public void log(){
        System.out.println("记录日志");
    }
}
在spring配置文件中加入：
<!-- 启动@aspectj的自动代理支持-->
    <aop:aspectj-autoproxy />
 
    <!-- 定义aspect类 -->
    <bean name="myAspect" class="cn.xh.dao. MyAspectLog "/>

当我们创建UserDao的对象userDao调用addUser方法的时候会打印“添加用户”，“记录日志”很神奇吧,究竟发生了什么？

明明addUser方法里面只有打印”添加用户”啊

这就是Spring AOP的强大之处，在运行时通过动态代理技术对UserDao的addUser方法进行了增强，添加了记录日志的功能。

动态代理其实就是在运行时动态的生成目标对象的代理对象，在代理对象中对目标对象的方法进行增强，关于动态代理技术我会在另一篇文章中详细介绍，现在先来看一下AOP中几个重要的概念：

作者：夏昊
链接：https://www.zhihu.com/question/24863332/answer/863736101
来源：知乎
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

通知：就是会在目标方法执行前后执行的方法

上面这个例子中：

@After(value="execution(* cn.xh.dao.UserDao.addUser(..))")
 public void log(){
 System.out.println("记录日志");
 }

这个方法就是通知，目标方法是UserDao类的addUser(),在addUser执行之后执行了log方法，所以log方法是后置通知，通过在方法上加上@After注解来表示。

通过通知和目标方法的执行顺序我们可以把通知分为五种：

前置通知（before）：在目标方法执行之前执行。

后置通知（after）:在目标方法执行之后执行

后置返回通知（after returning）:在目标方法返回之后执行，先执行后置通知再执行后置返回通知。

这三种通知的执行顺序如下：

try{
    try{
        //@Before
        method.invoke(..);
    }finally{
        //@After
    }
    //@AfterReturning
}catch(){
    //@AfterThrowing
}

异常通知(after throwing):在目标方法抛出异常时执行

环绕通知(around):在目标函数执行中执行

二：切入点：应用通知进行增强的目标方法

现在面临的问题是如何去描述这个需要被增强的目标方法，如果只是一个具体的方法需要增强那简单，通过类名和方法名找到它就可以了，但是往往真实的需求中很多方法需要同样的通知进行增强，Spring AOP为我们提供了一个描述方法的语法比如上例中的：

@After(value="execution(* cn.xh.dao.UserDao.addUser(..))")

execution(* cn.xh.dao.UserDao.addUser(..)就是用来描述需要应用通知的方法的。这里的含义是cn.xh.dao包UserDao类中的参数任意，返回值任意的addUser方法。

关于这种描述更多具体的写法我会在另一篇文章中详述。

三：连接点：连接点就是可以应用通知进行增强的方法

因为Spring Aop只能针对方法进行增强，所以这里的连接点指的就是方法，一旦连接点被增强，它就成为了切入点。

如上例中的：

public void addUser(){
 System.out.println("添加用户");
 }
 public void updateUser(){
 System.out.println("修改用户");
 }
 public void deleteUser(){
 System.out.println("删除用户");
 }
三个方法都是连接点。

四：切面：是切入点和通知的结合

可以用切面类来表示：

@Aspect
public class MyAspectLog {
    /**
     * 方法执行完后执行的方法
     */
@After(value="execution(* cn.xh.dao.UserDao.addUser(..))")
    public void log(){
        System.out.println("记录日志");
    }
}

在这个类中既包含了切入点addUser又包含了通知:log().

五：织入：就是通过动态代理对目标对象方法进行增强的过程

spring 支持几种 bean 的作用域？

当通过spring容器创建一个Bean实例时，不仅可以完成Bean实例的实例化，还可以为Bean指定特定的作用域。Spring支持如下5种作用域：

singleton：单例模式，在整个Spring IoC容器中，使用singleton定义的Bean将只有一个实例
prototype：原型模式，每次通过容器的getBean方法获取prototype定义的Bean时，都将产生一个新的Bean实例
request：对于每次HTTP请求，使用request定义的Bean都将产生一个新实例，即每次HTTP请求将会产生不同的Bean实例。只有在Web应用中使用Spring时，该作用域才有效
session：对于每次HTTP Session，使用session定义的Bean豆浆产生一个新实例。同样只有在Web应用中使用Spring时，该作用域才有效
globalsession：每个全局的HTTP Session，使用session定义的Bean都将产生一个新实例。典型情况下，仅在使用portlet context的时候有效。同样只有在Web应用中使用Spring时，该作用域才有效

Spring运行流程描述：

1. 用户向服务器发送请求，请求被Spring 前端控制Servelt DispatcherServlet捕获；

2. DispatcherServlet对请求URL进行解析，得到请求资源标识符（URI）。然后根据该URI，调用HandlerMapping获得该Handler配置的所有相关的对象（包括Handler对象以及Handler对象对应的拦截器），最后以HandlerExecutionChain对象的形式返回；

3. DispatcherServlet 根据获得的Handler，选择一个合适的HandlerAdapter；（附注：如果成功获得HandlerAdapter后，此时将开始执行拦截器的preHandler(...)方法）

4. 提取Request中的模型数据，填充Handler入参，开始执行Handler（Controller)。在填充Handler的入参过程中，根据你的配置，Spring将帮你做一些额外的工作：

HttpMessageConveter：将请求消息（如Json、xml等数据）转换成一个对象，将对象转换为指定的响应信息
数据转换：对请求消息进行数据转换。如String转换成Integer、Double等
数据根式化：对请求消息进行数据格式化。如将字符串转换成格式化数字或格式化日期等
数据验证：验证数据的有效性（长度、格式等），验证结果存储到BindingResult或Error中

5. Handler执行完成后，向DispatcherServlet 返回一个ModelAndView对象；

6. 根据返回的ModelAndView，选择一个适合的ViewResolver（必须是已经注册到Spring容器中的ViewResolver)返回给DispatcherServlet ；

7. ViewResolver 结合Model和View，来渲染视图；

8. 将渲染结果返回给客户端。

JVM 内存模型共分为5个区：堆(Heap)、方法区(Method Area)、程序计数器(Program Counter Register)、虚拟机栈(VM Stack)、本地方法栈(Native Method Stack)

TuxedoLinux

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
2020-11-22

新线程创建当程序调用start()方法时，会创建一个新线程，然后执行run()方法。但是如果我们直接调用run()方法，则不会创建新的线程，run()方法将作为当前调用线程本身的常规方法调用执行，并且不会发生多线程。Throw：作用在方法内，表示抛出具体异常，由方法体内的语句处理。具体向外抛出的动作，所以它抛出的是一个异常实体类。若执行了Throw一定是抛出了某种异常。Throws：作用在方法的声明上，表示如果抛出异常，则由该方法的调用者来进行异常处理。主要的声明这个方法会抛出会抛
复制链接

扫一扫