25-Java-Spring框架(三)

Spring框架的了解、SpringIOC的部分内容请阅读23-Java-Spring框架(一)

SpringwebMVC的了解、请求流程、运用等请阅读24-Java-Spring框架(二)

四、Spring AOP(Aspect Oriented Programming)

　　1.SpringAOP了解

　　　　SpringAOP将通用业务和传统业务隔离，通过AOP配置进行结合实现功能叠加的效果(可以利用低耦合模式实现通用业务的调用)

　　  　　   三个相关术语：1.Aspect(方面/切面)：指封装了通用业务逻辑，可以切入到其他目标上组件上的方法

　　　　　 　　　　　　    2.Pointcut(切入点)：指表达式，用于指定被切的目标组件和方法

　　　　　　　　　　　　　　(1)方法限定表达式：execution(修饰符  返回类型  方法名(参数列表)  抛出异常)

　　　　　　　　　　　　　　　　execution(* query*())　　表示所有以query开头的方法会被切入功能(第一个*表示方法返回类型，第二个*表示任意)

　　　　　　　　　　　　　　　　execution(* com.spring.*.*(..))　　表示所有以com.spring包下面的所有的类中的所有的方法会被切入功能

　　　　　　　　　　　　　　　　execution(* com.spring..*.*(..))　　表示所有以com.spring包以及子包下面的所有的类中的所有的方法会被切入功能

　　　　　　　　　　　　　　(2)类型限定表达式：within(包名.类名)

　　　　　　　　　　　　　　　　within(com.spring.controller.springtest)　　表示com.spring.controller包下的springtest组件类中的所有方法都会被切入

　　　　　　　　　　　　　　　　within(com.spring.controller..*)　　表示com.spring.controller包以及子包下的所有组件类中的所有方法都会被切入

　　　　　　　　　　　　　　(3)名称限定表达式：bean(id名称)

　　　　　　　　　　　　　　　　bean(student)　　表示id名称为student的bean对象的所有方法

　　　　　　　　　　　　　　　　bean(*ent)　　表示id名称为以ent结尾的bean对象的所有方法

　　　　　　　　　　　　　　　　bean(std*)　　表示id名称为以std开头的bean对象的所有方法

　　　　　 　　　　　　    3.Advice(通知)：指定切入时机，比如方法调用前，方法调用后，异常发生后等等

         try{
                 //环绕通知@Around(可以理解为前置通知加后置通知)

                 //前置通知@Before
                 //执行目标组件方法
                 //后置通知@AfterReturning
         } catch{
                 //异常通知@AfterThrowing  
         } finally{
                 //最终通知@After
         }    

　　2.AOP的运用案例一(案例：计时演示)

　　　　　　第一步：建立web项目

　　　　　　第二步：配置SpringIOC、SpringAOP、SpringMVC环境，引入相关jar包

　　　　　　第三步：配置web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="3.0" 
    xmlns="http://java.sun.com/xml/ns/javaee" 
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
    xsi:schemaLocation="http://java.sun.com/xml/ns/javaee 
    http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd">
  <display-name></display-name>    
  <welcome-file-list>
    <welcome-file>index.jsp</welcome-file>
  </welcome-file-list>
  
  <servlet>
      <servlet-name>springmvc</servlet-name>
      <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
      
      <init-param>
          <param-name>contextConfigLocation</param-name>
          <param-value>classpath:applicationContext.xml</param-value>
      </init-param>
      
      <load-on-startup>1</load-on-startup>
  </servlet>
  
  <servlet-mapping>
      <servlet-name>springmvc</servlet-name>
      <url-pattern>*.do</url-pattern>
  </servlet-mapping>
</web-app>

　　　　　　第四步：编写被切入的目标测试类(实现传统业务)

package com.springAOP.Target;

import org.springframework.stereotype.Component;

//切面的触发，都是service的对应代理去触发的，所以，你在service里面直接调用触发切面的方法，是达不到这个效果的，
//所以，需要使用这个ioc注入的代理对象，就会触发切面的方法啦
@Component("targetclass")
public class TargetClass {
    public void Studentfirst(){
        System.out.println("first Student");
    }
    public void Studentsecond(){
        System.out.println("second Student");
    }
    public void Studentthird(){
        System.out.println("third Student");
    }
}

　　　　　　第五步：编写通过AOP实现的通用业务的计时功能

package com.springAOP.AOPTimeTest;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.stereotype.Component;
import org.springframework.util.StopWatch;

@Component//加载SpringAOPTimeTest到Spring框架中
@Aspect//加载一个实现切面AOP功能的对象
public class SpringAOPTimeTest {
    
    @Around("within(com.springAOP.Target.*)")//表示com.springAOP.Target包的所有组件类中的所有方法都会被切入环绕通知
    public Object time(ProceedingJoinPoint pjp) throws Throwable{
        
        StopWatch watch = new StopWatch();//调用Spring框架封装好的计时类
        watch.start();//开始计时
        Object obj = pjp.proceed();//执行被切入的目标组件方法
        watch.stop();//结束计时
        
        String ClassName = pjp.getTarget().getClass().getName();//获取包名+类名
        String AdviceName = pjp.getSignature().getName();//获取方法名
        long time = watch.getTotalTimeMillis();//获取时间差
        System.out.println(ClassName+"."+AdviceName+"运行了"+time);
        
        return obj;
    }
}

　　　　　　第六步：配置applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<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"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:jdbc="http://www.springframework.org/schema/jdbc"
       xmlns:jee="http://www.springframework.org/schema/jee"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xmlns:util="http://www.springframework.org/schema/util"
       xsi:schemaLocation="
            http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
            http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd
            http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd
            http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd
            http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc.xsd
            http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee.xsd
            http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc.xsd
            http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
        
        <!-- 配置AOP组件aspectj自动代理 -->
        <aop:aspectj-autoproxy/>
        
        <!-- 配置组件扫描 -->
        <context:component-scan base-package="com.springAOP"/>
        
        <!-- 配置注解handler -->
        <mvc:annotation-driven/>
        
        <!-- 配置ViewResolver视图解析器 -->
        <!-- 完整的页面路径：前缀+视图名称+后缀 -->
        <bean id = "viewresolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
            <!-- 路径前缀 -->
            <property name="prefix" value="/"></property>
            <!-- 路径后缀 -->
            <property name="suffix" value=".jsp"></property>
        </bean>
</beans>

　　　　　　第七步：编写springMVC部分的Controller前端控制器，调用传统业务方法

package com.springAOP.mvccontroller;

import javax.annotation.Resource;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.ModelAndView;

import com.springAOP.Target.TargetClass;

@Controller//此处相当于继承了Controller接口的作用
public class StudentController {
    
    //切面的触发，都是service的对应代理去触发的，所以，你在service里面直接调用触发切面的方法，是达不到这个效果的，
    //所以，需要使用这个ioc注入的代理对象，就会触发切面的方法啦
    @Resource(name = "targetclass")
    private TargetClass tc;
    
    @RequestMapping("/stu.do")//此处等价于applicationContext.xml中的配置HandlerMapping组件
    public ModelAndView student(){
        tc.Studentfirst();
        tc.Studentsecond();
        tc.Studentthird();
        
        ModelAndView mac = new ModelAndView();
        mac.setViewName("index");
        mac.getModel();
        return mac;
    }
}

　　　　　　第八步：测试运行

　　　　　　　　　　

　　3.AOP运用案例二(案例：AOP实现异常抛出到日志)

　　　　　　第一步：建立web项目

　　　　　　第二步：配置SpringIOC、SpringAOP、SpringMVC环境，引入相关jar包(同案例一)

　　　　　　第三步：配置web.xml(同案例一)

　　　　　　第四步：编写被切入的目标测试类(实现传统业务)(同案例一)

　　　　　　第五步：编写通过AOP实现的通用业务的异常抛出功能

package com.springAOP.test;

import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.Date;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.stereotype.Component;
import org.springframework.util.StopWatch;

@Component//加载SpringAOPTimeTest到Spring框架中
@Aspect//加载一个实现切面AOP功能的对象
public class SpringAOPTest {
    
    @Around("within(com.springAOP.Target.*)")//表示com.springAOP.Target包的所有组件类中的所有方法都会被切入环绕通知
    public Object time(ProceedingJoinPoint pjp) throws Throwable{
        
        StopWatch watch = new StopWatch();//调用Spring框架封装好的计时类
        watch.start();//开始计时
        Object obj = pjp.proceed();//执行被切入的目标组件方法
        watch.stop();//结束计时
        
        String ClassName = pjp.getTarget().getClass().getName();//获取包名+类名
        String AdviceName = pjp.getSignature().getName();//获取方法名
        long time = watch.getTotalTimeMillis();//获取时间差
        System.out.println(ClassName+"."+AdviceName+"运行了"+time);
        
        return obj;
    }
    
    @AfterThrowing(throwing="ex",pointcut="within(com.springAOP..*)")//表示com.springAOP包以及子包的所有组件类中的所有方法都会被切入异常通知
    public void logException(Exception ex){
        
        //异常信息写入日志文件
        try {
            FileWriter fw = new FileWriter("F:\error.log",true);
            PrintWriter pw = new PrintWriter(fw);
            
            pw.println(new Date()+"发生了"+ex+"异常"+"详情如下：");
            StackTraceElement[] stackTrace = ex.getStackTrace();
            for(StackTraceElement s:stackTrace){
                if(s.toString().contains("com.springAOP")){//只写入重要的报错语句
                    pw.println(s);
                }
            }
            pw.println("=========================================================");
            pw.close();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

　　　　　　第六步：配置applicationContext.xml(同案例一)

　　　　　　第七步：编写springMVC部分的Controller前端控制器，调用传统业务方法

package com.springAOP.mvccontroller;

import javax.annotation.Resource;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.ModelAndView;

import com.springAOP.Target.TargetClass;

@Controller//此处相当于继承了Controller接口的作用
public class StudentController {
    
    //切面的触发，都是service的对应代理去触发的，所以，你在service里面直接调用触发切面的方法，是达不到这个效果的，
    //所以，需要使用这个ioc注入的代理对象，就会触发切面的方法啦
    @Resource(name = "targetclass")
    private TargetClass tc;
    
    @RequestMapping("/stu.do")//此处等价于applicationContext.xml中的配置HandlerMapping组件
    public ModelAndView student(){
        tc.Studentfirst();
        tc.Studentsecond();
        tc.Studentthird();
        
        ModelAndView mac = new ModelAndView();
        mac.setViewName("index");
        mac.getModel();
        
        //此处用于异常报错
        String str = null;
        str.length();
        return mac;
    }
}

　　　　　　第八步：测试运行

　　　　　　　　

　　3.SpringAOP原理

　　　　　　在使用AOP之后，Spring容器返回的是组件对象，是采用动态代理技术生成一个动态代理对象(是原有组件对象的子类)，

　　　　对原有组件的方法进行重写，在重写方法中调用切面组件追加功能和原有组件的功能。

　　　　　　动态代理：JDK动态代理：依赖于接口

　　　　　　　　　　　CGLIB动态代理：不依赖于接口

　　　　　　CGLIB技术：采用子类模式生成动态代理对象，默认目标组件没有接口采用

　　　　　　　　　　　　在使用中，可以追加<aop:aspectj-autoproxy  proxy-target-class="true"/> 强制采用CGLIB模式生成动态代理对象，建议使用，因为更安全

　　　　　　Proxy技术：采用接口模式生成动态代理对象，默认目标组件有接口采用