Spring 的IOC和AOP以及动态代理

spring全家桶：spring ， springmvc ，spring boot , spring cloud

1. 依赖

class a中使用class b的属性或者方法， 叫做classa依赖classb

Spring

1. IOC(控制反转)

IoC (Inversion of Control) : 控制反转， 是一个理论，概念，思想。
描述的：把对象的创建，赋值，管理工作都交给代码之外的容器实现。

控制： 创建对象，对象的属性赋值，对象之间的关系管理。
反转： 把容器代替开发人员管理对象。创建对象，给属性赋值。

正转：由开发人员在代码中，使用new 构造方法创建对象， 开发人员主动管理对象。

public static void main(String args[]){
        Student student = new Student(); // 在代码中， 创建对象。--正转。

	 }

容器：是一个服务器软件， 一个框架（spring）

为什么要使用 ioc ：

目的就是减少对代码的改动， 也能实现不同的功能。 实现解耦合

java中创建对象有哪些方式：

1. 构造方法 ， new Student（）
  2. 反射
  3. 序列化
  4. 克隆
  5. ioc ：容器创建对象
  6. 动态代理

ioc的体现：

servlet  1： 创建类继承HttpServelt 
	         2:  在web.xml 注册servlet ， 使用
	         <servlet-name> myservlet </servlet-name>
				                                 <servelt-class>com.bjpwernode.controller.MyServlet1</servlet-class>

            3. 没有创建 Servlet对象， 没有 MyServlet myservlet = new MyServlet()

				4. Servlet 是Tomcat服务器它能你创建的。 Tomcat也称为容器
				   Tomcat作为容器：里面存放的有Servlet对象， Listener ， Filter对象

junit : 单元测试， 一个工具类库，做测试方法使用的。

使用单元测试
   1.需要加入junit依赖。
	  <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
      <scope>test</scope>
    </dependency>

  2.创建测试作用的类：叫做测试类
    src/test/java目录中创建类

  3.创建测试方法

    1）public 方法
	 2）没有返回值 void 
	 3）方法名称自定义，建议名称是test + 你要测试方法名称
	 4）方法没有参数
	 5）方法的上面加入 @Test ,这样的方法是可以单独执行的。 不用使用main方法

IOC如何创建对象

1、声明一个bean,就是告诉spring要创建某个类的对象
id：对象的自定义名称，spring就是通过这个ID找到对象
class：类的全路径名称
Spring b把创建的对象放在map集合，
SpringMap.put(id , 对象)

xml文件 这就创建对象了
<bean id = "要创建对象的类名 别名 也可以是一样的 如：SomeServiceImpl的别名someService" class = "SomeServiceImpl的全路径名称" />

一个测试类 
@Test
public voidtest（）{
	// 使用spring容器创建对象
	1、指定spring配置文件的名称
	
	String config = "bean.xml";
	
    2、创建spring容器对象 ApplicationContext
    
    ApplicationContext ac = new ClassPathXmlApplicationContext(config);
    
    3、从容器中取对象 getbean(配置文件中bean的id)
    
    SomeService s = (SomeService)ac.getbean("someService");
    
	4、使用spring创建对象
	s.dosome();  // dosome 是SomeService类中的方法
	
}

如同 SomeServiceImpl s = new SomeServiceImpl();
s.dosome();

IoC的技术实现

DI 是ioc的技术实现，
DI（Dependency Injection） :依赖注入， 只需要在程序中提供要使用的对象名称就可以， 至于对象如何在容器中创建，
赋值，查找都由容器内部实现。
spring是使用的di实现了ioc的功能， spring底层创建对象，使用的是反射机制。
spring是一个容器，管理对象，给属性赋值， 底层是反射创建对象。

set方法注入

类：
public class Student(){
	private String name;
	private int age;
	private School school； //引用数据类型
	无参构造函数
	有参的构造函数
	
	
	private void setName(String name){
		this.name = name;
	}
	private void setAge(int age){
		this.age= age;
	}
	private void setschool(School school){
		this.school= school;
	}
}
public class School (){
	private String name;
    无参构造函数
	有参的构造函数
	 
	private void setName(String name){
		this.name = name;
	}
	
	
}

Spring 调用类中的set方法，给参数注入值
语法：

简单类型的set注入

> 1、语法
> > <bean id = "要创建对象的类名 如：someService" class = "SomeService的全路径名称" >
		<property name = "参数名" value="值"/>
</bean>

xml文件
<bean id = "student" class = "Student的全路径名称" >
		<property name = "name" value="老师"/>
		<property name = "age" value="20"/>
</bean>

引用数据类型的set注入

2、语法
<bean id = "要创建对象的类名 如：someService" class = "SomeService的全路径名称" >
		<property name = "参数名" ref=" 要引用的对象的bean的id"/>
</bean>

<bean id = "student" class = "Student的全路径名称" >
		<property name = "name" value="老师"/>
		<property name = "age" value="20"/>
		<property name = "school" ref="school"/>
</bean>
<bean id = "school" class = "School的全路径名称" >
		<property name = "name" value="清华"/>	
</bean>

构造方法的注入

spring调用有参构造方法。在创建对象的时候注入值

语法
<bean id = "要创建对象的类名 如：someService" class = "SomeService的全路径名称" >
		<donstructor-arg name = "参数名" value = "值"/>  name :构造方法的形参名  
		或者
		<donstructor-arg index= "0" value = "值"/>  index 构造方法的形参名的位置 0  1  2 
		 或者
		 value 构造方法的形参是简单类型的
		 ref：构造方法形参是引用类型
</bean>

<bean id = "student" class = "Student的全路径名称" >
		<donstructor-arg name = "name" value = "张三"/> 
		<donstructor-arg name = "age" value = "20"/>  name :构造方法的形参名  
		或者
		<donstructor-arg index= "0" value = "张三"/>  index 构造方法的形参名的位置 0  1  2 
		<donstructor-arg index= "1" value = "20"/>
	    <donstructor-arg index= "3" ref= "school"/>
		 ref：构造方法形参是引用类型s
		 
</bean>
<bean id = "school" class = "School的全路径名称" >
		<property name = "name" value="清华"/>	
</bean>

引用数据类型的自动注入

byName

1、byName(按名称注入)：Java类中引用数据类型的属性名和spring容器中（配置文件）引用类性的bean id 名一样 
<bean id = "myStudent" class = "Student的全路径名称" autowire = "byName">
		基本数据类型的赋值
		</bean>

<bean id = "myStudent" class = "Student的全路径名称" autowire = "byName">
		<donstructor-arg name = "name" value = "张三"/> 
		<donstructor-arg name = "age" value = "20"/>  name :构造方法的形参名 	
			
	    // <donstructor-arg index= "3" ref= "school"/>
		 ref：构造方法形参是引用类型
</bean>
<bean id = "school" class = "School的全路径名称" >
		<property name = "name" value="清华"/>	
</bean>

byType

byType:按照类型注入 
	   Java类中引用类型的数据类型和spring容器中（配置文件）bean 的class 属性是同源关系的 如在一个包下
	   同源 就是一类的意思
	   1、Java类中引用类型 的数据类型和bean的class的值一样
	   2、Java类引用类型的数据类型和bean的class的值是父字关系
	   3、Java类引用类型的数据类型和bean的class的值是接口和实现类的关系
语法

<bean id = "myStudent" class = "Student的全路径名称" autowire = "byType">
		基本数据类型的赋值
		</bean>

<bean id = "myStudent" class = "Student的全路径名称" autowire = "byType">
		<donstructor-arg name = "name" value = "张三"/> 
		<donstructor-arg name = "age" value = "20"/>  name :构造方法的形参名 	
			
	    // <donstructor-arg index= "3" ref= "school"/>
		 ref：构造方法形参是引用类型
</bean>
<bean id = "school" class = "School的全路径名称" >
		<property name = "name" value="清华"/>	
</bean>

管理对各配置文件

多个配置文件： 一个模块一个文件
如 学生一个
班级一个
学习一个

语法
再创建一个主配置文件
<beans>
	<import resource = ClassPath:其他配置文件的路径
</beans>

<beans>
	<import resource = ClassPath:student.xml的路径
	<import resource = ClassPath:student.xml的路径
</beans>

使用注解注入

通过注解完成对象的创建，代替xml
1、加入spring-context依赖
2、在类中创建注解
3、创建spring的配置文件
扫描器：指定注解在项目中的位置
4、使用注解创建对象，创建容器ApplicationContext

@Component(对象的名称也就是bean的id)

此注解创建对象 等同 bean的功能 等同于
位置：类的上面
@Component() 默认名称 类名的首字母小写 student

配置文件

配置扫描器：component - scan
base-package:注解在项目的包名
工作方法 ：spring扫码指定的包 找到注解 创建对象 赋值

三种方法
1、	<context：component-scan_base-package="包名1">
	<context：component-scan_base-package="包名2">
2、<context：component-scan_base-package="包名1;包名2">
3、指定父包 
<context：component-scan_base-package="父包名">

@Component("student")
public class Student(){
	private String name;
	private int age;
	private School school； //引用数据类型
	无参构造函数
	有参的构造函数
	
	
	private void setName(String name){
		this.name = name;
	}
	private void setAge(int age){
		this.age= age;
	}
	private void setschool(School school){
		this.school= school;
	}
}

其他创建对象的注解

这三个给项目分层

1. @Repository() 用在持久层，dao的实现类上面 表示创建对象dao能访问数据库
2. @Service（）业务层在service的实现类上，创建service对象，做业务处理，有事务等功能
3. @Controller() 控制层：创建控制器对象，接收用户处理的参数，显示请求的结果

注解注入赋值

@Value(“张飞”) ：简单数据类型赋值
用在String 类型上，基本数据类型不OK 可以使用包装类
无需set方法
位置 参数上

	@Value("李双")
	private String name;
	@Value("20")
	private int age;
	 //引用数据类型

引用数据类型注解注入@Autowired

:自动注入原理 支持byName 、byType； 默认byType
位置：在属性的上面
属性：required = true 赋值失败程序报错
required = false 赋值失败正常执行、引用数据为null

   @Autowired
	private int age;

使用byName
在属性上加@Autowired
@Qualifier(value = “bean的id”)表示指定名称的bean完成赋值

@Autowired
@Qualifier("school")
private School school；

引用数据类型注解赋值@Resource

默认byName 失败用byType
位置参数上面

@Resource
private School school

--------------------AOP切面--------------------

动态代理

1、实现方法：jdk动态代理，使用jdk中的Proxy，Method，InvocaitonHanderl创建代理对象。
jdk动态代理要求目标类必须实现接口
2.动态代理的作用：
1）在目标类源代码不改变的情况下，增加功能。
2）减少代码的重复
3）解耦合。

步骤：

1、 定义一个接口
2、定义一个类ServiceTools 类中有共有的方法 （时间、事务）doLog();doTrans();
2、定义一个接口的实现类，继承接口 重新方法 doSome();

3、写代理类：

继承IncationHandler实现代理

public Class MyIncationHandler implement IncationHandler(){
	private Object target;// 实现类
	public MyIncationHandler(Object target){
		this target = target;
	}
	public Object invoke(Object proxy,Method method, Object[] args)throws Throwable{
		// 通过代理对象执行方法 会调用这个invoke()
		Object res = null;
		ServiceTools.doLog();
		// 执行目标类的方法，通过Method类实现
		res = method.invoke(target,args);//执行实现类的方法
		ServiceTools.doTrans();
		// 目标方法的执行结果
		return res;
		
	}
}

使用jdk实现代理

public class MyApp(){
	public static void main(String[] args){
		SomeService target = new 实现类；
		// 创建InvocationHandler
		InvocationHandler handler = new MyIncationHandler(target);
		// 使用proxy创建代理
		SomeService proxy = (SomeService)Proxy.newProxyInsstance{
			target.getClass().getClassLoader(),
			target.getClass().getInterFaces(),Handler);
			// 调用handler中的invoke();
			proxy.dosome();
		}
	}
}

aspectj实现AOP

步骤
1、新建maven项目
2、加入依赖
aspectj依赖
juint单元测试
3、创建目标类：接口和实现类
4、创建切面类：普通类
（1）在类上加入@Aspect
(2) 在类中的定义方法,方法就是切面执行的代码（事务、日志、时间等）
在方法上加入aspectj的通知注解。如@before
有需要则指定切入表达式
5、创建spring配置文件，声明对象，把对象交给IOC管理
（1）声明目标对象
（2）声明切面类对象
（3）声明aspectj框架中自动代理生成器标签
6创建测试类

接口`

public interface SomeService{
	void doSome(String name,Integer age);
}

实现类

public class SomeServiceImpl implements SomeService {
	@Override
	public void doSome(String name,Integer age){
	Sysotem.out.println("执行----------")
	}
}

切面类

@Aspect
public class MyAspect{
	方法要求
		1、public
		2、void
		3、方法名自定义
		4、方法可以有参数也可以无参数
		5、@Before前置注解 
			1、属性 Value 切入表达式，表示切面的执行位置
			2、位置 ：在方法的上面
			
	@Before(value = "execution(public void 包下的实现类.doSome(String,Integer)")
	public void myBefore(){
	//切面的代码
	 Sysotem.out.println("时间----------")
	}
}

配置文件

// 声明目标类（实现类）对象
<bean id = "someService" class = "路径名" />
// 声明切面类对象
<bean id = "myAspect" class = "全路径名" />

//声明aspectj框架中自动代理生成器标签
<aop:aspectj-autoproxy>

后置通知@AfterReturn()

要求
1、public
2、void
3、方法有参数 Object 方法名自定义
4、属性 1、value：切入点表达式
		2、returning 自定义的变量，便是目标方法有返回值的
		自定义的变量名必须和通知方法的形参一样
位置： 方法上面

切面类 中的方法
@@AfterReturn(value = "execution(public void 包下的实现类.doSome(String,Integer)",returning = "res")
	public void myAfterReturn(Object res){  res 和,returning = "res一样
	//切面的代码
	 Sysotem.out.println("时间----------")

环绕通知@Around

属性：value:切入表达式
位置：方法上方

特点

功能最强的通知
在目标方法前后都能加入切面类的代码
控制目标方法是否调用执行
修改原目标方法的执行结果，影响最后的调用结果

@Around(value = "execution(public void 包下的实现类.doSome(String,Integer)")
public Object myAround(ProceedingJoinPoint pjp) throws Throwable{
	// 实现环体通知
	Object result = null;
	Sysotem.out.println("方法前")
	// 目标方法调用
	result = pjp.proceed(); 
	Sysotem.out.println("方法后")
	// 返回目标方法的执行结果
	return result;

}

AOP项目使用

自定义注解，哪里使用哪里用 aop切面

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface MyLog {

    String value() default "";
}

切面类，其中可以获取 请求ip url 参数以及返回结果

package com.springboot.shiro.aop;

import com.springboot.shiro.entiy.LogRecords;
import lombok.extern.slf4j.Slf4j;
import org.apache.shiro.SecurityUtils;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.Signature;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServletRequest;
import java.lang.reflect.Method;
import java.util.*;

@Aspect
@Component
public class LogAspect {

    private final Logger logger = LoggerFactory.getLogger(LogAspect.class);


    //基本类型定义，用于判断请求参数的类型
    private static List typeList = new ArrayList();
    private static String[] types = {"java.lang.Integer", "java.lang.Double",
            "java.lang.Float", "java.lang.Long", "java.lang.Short",
            "java.lang.Byte", "java.lang.Boolean", "java.lang.Char",
            "java.lang.String", "int", "double", "long", "short", "byte",
            "boolean", "char", "float"};

    static {
        for (int i =0;i<types.length;i++){
            typeList.add(types[i]);
        }
    }

    @Pointcut(value = "@annotation(MyLog)")
    public void pointcut() {
    }

    @Around("pointcut()")
    public String afterProcess(ProceedingJoinPoint joinPoint) throws Throwable{
        HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
        String ipAddr = getRemoteHost(request);
        String url = request.getRequestURL().toString();
        String result = coreHandle(joinPoint, request);

        logger.info("请求源IP:【{}】,请求URL:【{}】,操作结果：【{}】",ipAddr,url,result);
        return result;
    }

    /**
     * 核心处理  
     * @param joinPoint
     * @param request
     * @return
     */
    public String coreHandle(ProceedingJoinPoint joinPoint, HttpServletRequest request) throws Throwable{
        Signature signature = joinPoint.getSignature();
        MethodSignature methodSignature = (MethodSignature) signature;
        // 通过这获取到方法的所有参数名称的字符串数组
        String[] parameterNames = methodSignature.getParameterNames();//获取到所有参数的NAME
        Object[] args = joinPoint.getArgs(); //获取到所有参数的VALUE
        StringBuilder sb = new StringBuilder();
        Map paramMap = new HashMap();
        if (parameterNames != null && parameterNames.length > 0 && args != null && args.length > 0) {
            for (int i = 0; i < parameterNames.length; i++) {
                //考虑入参要么为基础类型参数，要么为对象类型。以下方法都适合解析出来
                if (typeList.contains(args[i].getClass().getTypeName())){
                    //基本数据类型
                    paramMap.put(parameterNames[i],JSON.toJSONString(args[i]));
                }else{
                    //实体类
                    paramMap = JSON.parseObject(JSON.toJSONString(args[i]));
                }
            }
        }

        for (Object key: paramMap.keySet()) {
            System.out.println("key = "+ key.toString());
        }
        for (Object key: paramMap.values()) {
            System.out.println("value = "+ key.toString());
        }
        Method targetMethod = methodSignature.getMethod(); //获取到具体的被AOP的方法
        MyLog methodAnno = targetMethod.getAnnotation(MyLog.class);//获取到方法上的某个特定注解

        //进入后置处理，根据controller返回结果来判断是否成功
        String result= (String) joinPoint.proceed();
        String respParam = postHandle(result);
//        JSONObject jsonObject = JSONObject.parseObject(respParam);
        return result;
    }

    /**
     * 返回数据
     * @param retVal
     * @return
     */
    private String postHandle(Object retVal) {
        if(null == retVal){
            return "";
        }
        return JSON.toJSONString(retVal);
    }


    /**
     * 获取目标主机的ip
     * @param request
     * @return
     */
    private String getRemoteHost(HttpServletRequest request) {
        String ip = request.getHeader("x-forwarded-for");
        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getHeader("Proxy-Client-IP");
        }
        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getHeader("WL-Proxy-Client-IP");
        }
        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getRemoteAddr();
        }
        return "0:0:0:0:0:0:0:1".equals(ip) ? "127.0.0.1" : ip;
    }


    /**
     * 获取随机串
     * @param length
     * @return
     */
    public static String genrateRandomCode(int length){
        StringBuffer buffer = new StringBuffer();
        Random r = new Random();
        for (int i = 0;i < length; i++){
            int number = r.nextInt(9);
            buffer.append(number);
        }
        return buffer.toString();
    }



}

在 这使用 自定义注解，在调用这个请求的时候就会使用 AOP

    @GetMapping("/noauto")
    @ResponseBody
    @MyLog
    public String unauthorized(@RequestParam  String username,@RequestParam String password){
//        throw new RuntimeException();
        return "111";
    }

结果