3.spring基础入门(三)-优快云博客

1.实际开发的使用

实际开发中我们会将程序分为三层：

Controller
Service
Repository（DAO）

关系 Controller --》Service --〉Repository

@Component 注解是将标注的类加载到 IoC 容器中，实际开发中可以根据业务需求分别使⽤

@Controller、@Service、@Repository 注解来标注控制层类、业务层类、持久层类。

Controller

package com.southwind.controller;
import com.southwind.service.MyService;
import lombok.Setter;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
@Setter
@Controller
public class MyController {
     @Autowired
     private MyService myService;
     /**
     * 模拟客户端请求
     */
     public String service(Double score){
         return myService.doService(score);
     }
}

Service

package com.southwind.service;

public interface MyService {
     public String doService(Double score);
}

package com.southwind.service.impl;
import com.southwind.repository.MyRepository;
import com.southwind.service.MyService;
import lombok.Setter;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Setter
@Service
public class MyServiceImpl implements MyService {
     @Autowired
     private MyRepository myRepository;
     @Override
     public String doService(Double score) {
         return myRepository.doRepository(score);
     }
}

Repository

package com.southwind.repository;
public interface MyRepository {
     public String doRepository(Double score);
}

package com.southwind.repository.impl;
import com.southwind.repository.MyRepository;
import org.springframework.stereotype.Repository;

@Repository
public class MyRepositoryImpl implements MyRepository {
    @Override
    public String doRepository(Double score) {
        String result = "";
        if(score < 60){
            result = "不及格";
        }
        if(score >= 60 && score < 80){
            result = "合格";
        }
        if(score >= 80){
            result = "优秀";
        }
        return result;
    }
}

spring.xml

<context:component-scan base-package="com.southwind"></context:component-scan>

Spring AOP

AOP（Aspect Oriented Programming）⾯向切⾯编程。
OOP（Object Oriented Programming）⾯向对象编程，⽤对象化的思想来完成程序。
AOP 是对 OOP 的⼀个补充，是在另外⼀个维度上抽象出对象

具体是指程序运⾏时动态地将⾮业务代码切⼊到业务代码中，从⽽实现程序的解耦合，将⾮业务代码抽

象成⼀个对象，对对象编程就是⾯向切⾯编程。

上述形式的代码维护性差，没有代码复⽤性，使⽤ AOP 进⾏优化，如下图所示

1.AOP 的优点：

可以降低模块之间的耦合性
提⾼代码的复⽤性
提⾼代码的维护性
集中管理⾮业务代码，便于维护
业务代码不受⾮业务代码的影响，逻辑更加清晰

1、创建⼀个计算器接⼝ Cal

package com.southwind.aop;
public interface Cal {
     public int add(int num1,int num2);
     public int sub(int num1,int num2);
     public int mul(int num1,int num2);
     public int div(int num1,int num2);
}

2、创建接⼝的实现类 CalImpl

package com.southwind.aop.impl;
import com.southwind.aop.Cal;
public class CalImpl implements Cal {
     @Override
     public int add(int num1, int num2) {
         int result = num1 + num2;
         return result;
     }
     @Override
     public int sub(int num1, int num2) {
         int result = num1 - num2;
         return result;
     }
     @Override
     public int mul(int num1, int num2) {
         int result = num1 * num2;
         return result;
     }
     @Override
     public int div(int num1, int num2) {
         int result = num1 / num2;
         return result;
     }
}

⽇志打印

在每个⽅法开始位置输出参数信息。
在每个⽅法结束位置输出结果信息。

对于计算器来讲，加减乘除就是业务代码，⽇志打印就是⾮业务代码。

AOP 如何实现？使⽤动态代理的⽅式来实现。

代理⾸先应该具备 CalImpl 的所有功能，并在此基础上，扩展出打印⽇志的功能。

1、删除 CalImpl ⽅法中所有打印⽇志的代码，只保留业务代码。

2、创建 MyInvocationHandler 类，实现 InvocationHandler 接⼝，⽣成动态代理类。

动态代理类，需要动态⽣成，需要获取到委托类的接⼝信息，根据这些接⼝信息动态⽣成⼀个代理类，

然后再由 ClassLoader 将动态⽣成的代理类加载到 JVM。

package com.southwind.aop;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.Arrays;

public class MyInvocationHandler implements InvocationHandler {
     //委托对象
     private Object object = null;
     //返回代理对象
     public Object bind(Object object){
     this.object = object;
     return Proxy.newProxyInstance(
                 object.getClass().getClassLoader(),
                 object.getClass().getInterfaces(),
                 this
     );
 }
    
 @Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    //实现业务代码和⾮业务代码的解耦合
     System.out.println(method.getName()+"⽅法的参数是"+ Arrays.toString(args));
     Object result = method.invoke(this.object,args);
     System.out.println(method.getName()+"⽅法的结果是"+ result);
     return result;
}

test.java

package com.southwind.aop;
import com.southwind.aop.impl.CalImpl;
public class Test {
      public static void main(String[] args) {
         //实例化委托对象
         Cal cal = new CalImpl();
         //获取代理对象
         MyInvocationHandler myInvocationHandler = new MyInvocationHandler();
         Cal proxy = (Cal) myInvocationHandler.bind(cal);
         proxy.add(10,3);
         proxy.sub(10,3);
         proxy.mul(10,3);
         proxy.div(10,3);
     }
}

上述代码通过动态代理机制实现了业务代码和⾮业务代码的解耦合，这是 Spring AOP 的底层实现机

制，真正在使⽤ Spring AOP 进⾏开发时，不需要这么复杂，可以⽤更好理解的⽅式来完成开发。

2.Spring AOP 的开发步骤

1、创建切⾯类。

package com.southwind.aop;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;
import java.util.Arrays;
@Component
@Aspect
public class LoggerAspect {
     @Before("execution(public int com.southwind.aop.impl.CalImpl.*(..))")
     public void before(JoinPoint joinPoint){
         String name = joinPoint.getSignature().getName();
         String args = Arrays.toString(joinPoint.getArgs());
         System.out.println(name+"⽅法的参数是"+args);
     }
     @After("execution(public int com.southwind.aop.impl.CalImpl.*(..))")
     public void after(JoinPoint joinPoint){
         String name = joinPoint.getSignature().getName();
         System.out.println(name+"⽅法执⾏完毕");
     }
     @AfterReturning(value = "execution(public int com.southwind.aop.impl.CalImpl.*(..))",returning = "result")
     public void afterReturn(JoinPoint joinPoint,Object result){
         String name = joinPoint.getSignature().getName();
         System.out.println(name+"⽅法的结果是"+result);
     }
     @AfterThrowing(value = "execution(public int com.southwind.aop.impl.CalImpl.*(..))",throwing = "ex")
     public void afterThrowing(JoinPoint joinPoint,Exception ex){
         String name = joinPoint.getSignature().getName();
         System.out.println(name+"⽅法抛出异常"+ex);
     }
}

@Component，将切⾯类加载到 IoC 容器中。
@Aspect，表示该类是⼀个切⾯类。
@Before，表示⽅法的执⾏时机是在业务⽅法之前，execution 表达式表示切⼊点是 CalImpl 类中的 add ⽅法。
@After，表示⽅法的执⾏时机是在业务⽅法结束之后，execution 表达式表示切⼊点是 CalImpl 类中的 add ⽅法。
@AfterReturning，表示⽅法的执⾏时机是在业务⽅法返回结果之后，execution 表达式表示切⼊点是 CalImpl 类中的 add ⽅法，returning 是将业务⽅法的返回值与切⾯类⽅法的形参进⾏绑定。
@AfterThrowing，表示⽅法的执⾏时机是在业务⽅法抛出异常之后，execution 表达式表示切⼊点是 CalImpl 类中的 add ⽅法，throwing 是将业务⽅法的异常与切⾯类⽅法的形参进⾏绑定。

2、委托类也需要添加 @Component

package com.southwind.aop.impl;
import com.southwind.aop.Cal;
import org.springframework.stereotype.Component;
@Component
public class CalImpl implements Cal {
     @Override
     public int add(int num1, int num2) {
         int result = num1 + num2;
         return result;
     }
     @Override
     public int sub(int num1, int num2) {
         int result = num1 - num2;
         return result;
     }
     @Override
     public int mul(int num1, int num2) {
         int result = num1 * num2;
         return result;
     }
     @Override
     public int div(int num1, int num2) {
         int result = num1 / num2;
         return result;
     }
}

3、spring.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:p="http://www.springframework.org/schema/p"
 xsi:schemaLocation="http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop-4.3.xsd
 http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-4.3.xsd
 http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-4.3.xsd
">

 <context:component-scan base-package="com.southwind.aop"></context:component-scan>

 <aop:aspectj-autoproxy></aop:aspectj-autoproxy>

</beans>