Spring框架概述

1.Spring 是一个开源框架.

Spring 为简化企业级应用开发而生. 使用 Spring 可以使简单的 JavaBean 实现以前只有 EJB 才能实现的功能.

Spring 是一个 IOC(DI) 和 AOP 容器框架

具体描述 Spring:

轻量级：Spring 是非侵入性的 - 基于 Spring 开发的应用中的对象可以不依赖于 Spring 的 API

依赖注入(DI --- dependency injection、IOC)

面向切面编程(AOP --- aspect oriented programming)

容器: Spring 是一个容器, 因为它包含并且管理应用对象的生命周期

框架: Spring 实现了使用简单的组件配置组合成一个复杂的应用. 在 Spring 中可以使用 XML 和 Java 注解组合这些对象

一站式：在 IOC 和 AOP 的基础上可以整合各种企业应用的开源框架和优秀的第三方类库 （实际上 Spring 自身也提供了展现层的 SpringMVC 和 持久层的 Spring JDBC）

二、Spring入门程序（理解控制反转IoC）

导入jar包

创建UserDao接口，并创建该接口的实现类UserDaoImpl

//UserDao接口
package com.ye.dao;
 
public interface UserDao {
    public void sayHi();
    
}
 
//UserDao接口的实现类UserDaoImpl
package com.haust.dao.impl;
 
import com.ye.dao.UserDao;
 
public class UserDaoimpl implements UserDao {
 
    @Override
    public void sayHi() {
        System.out.println("UserDao say hello");
 
    }
 
}

创建Spring的配置文件ApplicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
    <!--将指定类配置给Spring，让Spring创建其对象的实例-->
    <bean id="userDao" class="com.ye.dao.impl.UserDaoimpl"></bean
    
</beans>

创建测试类TestIoC.java

package com.ye.text;
 
import java.lang.reflect.Constructor;
 
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
 
import com.haust.dao.UserDao;
public class UserText {
    @Test
    public void run1(){
        //1.创建容器对象
        ApplicationContext applicationContext = 
                new ClassPathXmlApplicationContext("applicationContext.xml");
        //2.通过容器对象获取bean对象
        UserDao userdao = (UserDao)applicationContext.getBean("userDao");
        //3.调用实例中的say()方法
        userdao.say();
    }
}

三、依赖注入（Dependency Injection，DI）
依赖注入（DI）和控制反转（IoC）的含义相同，只是从两个角度去描述了同一个概念。

当某个Java对象（调用者）需要调用另一个Java对象（被调用者）时，在传统模式下，调用者通常会采用“new被调用者”的代码方式来创建对象，这样会导致调用者与被调用者之间的耦合性增加，不利于后期项目的升级和维护。

在使用Spring框架后，对象的实例不再由调用者来创建，而是由Spring容器来创建，Spring容器会负责控制程序之间的关系，而不是由调用者的程序代码直接控制，这样，控制权由应用代码转移到了Spring容器，控制权发生了反转，这就是Spring的控制反转。

从Spring容器的角度来看，Spring容器负责将被依赖对象赋值给调用者的成员变量，这相当于为调用者注入了它依赖的实例，这就是依赖注入。

3.1 依赖注入的实现方式
（1）属性setter方法注入

指Spring容器使用setter方法注入被依赖的实例，通过调用无参构造器或者无参静态工厂方法实例化Bean后，调用该Bean的setter方法，就可以实现基于setter方法的依赖注入。

简单说就是，在调用者的实例中声明一下被调用者，并生成一个被调用者的setter方法即可，然后在配置文件中依赖注入被调用者的Bean，实质就是调用了该Bean中的setter方法。

构造方法注入

指Spring容器使用构造方法注入被依赖的实例。基于构造方法的依赖注入通过调用带参数的构造方法来实现，每个参数代表这一个依赖。

使用一个实例来说明Spring中如何实现依赖注入
（一）创建UserService接口及其实现类UserServiceImpl

//UserService接口
package com.ye.service;
 
public interface UserService {
    public void sayHi();
}
 
 
//UserService接口的实现类UserServiceImpl
package com.haust.service.impl;
 
import com.ye.dao.UserDao;
import com.ye.service.UserService;
 
public class UserServiceimpl implements UserService {
    
    private UserDao userDao;
    
    //添加UserDao属性的setter方法，用于实现依赖注入
    public void setUserDao(UserDao userdao) {
        this.userDao = userdao;
    }
    
    //实现接口中的方法
    @Override
    public void sayHi() {
        //调用userDao中的say()方法，并执行输出语句
        userDao.sayHi();
        System.out.println("UserService say hello");
 
    }
 
}

(二)在配置文件中添加userService的Bean，并将userDao的实例注入到userService中

<bean id="userService" class="com.fu.service.impl.UserServiceimpl">
        <property name="userDao" ref="userDao"></property>
</bean>

(三)创建测试类

@Test
    public void run12(){
        //1.创建容器对象
        ApplicationContext applicationContext = 
                new ClassPathXmlApplicationContext("applicationContext.xml");
        //2.通过容器对象获取bean对象
        UserService user = (UserService)applicationContext.getBean
       ("userService");
        user.sayHi();
    }

四、什么是AOP
（1）面向切面编程（方面），利用AOP可以对业务逻辑的各个部分进行隔离，从而使得
             业务逻辑各部分之间的合度降低，提高程序的可重用性，同时提高了开发的效率。
 （2）通俗描述：不通过修改源代码方式，在主要功能里面添加新功能

AOP（底层原理）
1、AOP底层使用动态代理（通过代理实现功能增加不修改源码）
（1）有两种情况动态代理
第一种有接口情况，使用jdk动态代理

第二种没有接口情况，使用CGLIB动态代理 

        创建子类的代理对象，增强类的方法

编写JDK动态代理代码
 （1）创建接口，定义方法

public interface UserDao {
    public int add(int a,int b);
    public String update(String id);
}
 
 
public class UserDaoImp1 implements UserDao{
    @Override
    public int add(int a) {
        System.out.println("add方法执行了");
        return a;
    }
 
    @Override
    public String update(String id) {
        System.out.println("update方法执行了");
        return id;
    }
}

（2）创建接口实现类，实现方法.，创建代理对象。需要用到的方法

 每一个动态代理类的调用处理程序都必须实现InvocationHandler接口，当我们通过动态代理对象调用一个方法时候，这个方法的调用就会被转发到实现InvocationHandler接口类的invoke方法来调用

public class JDKProxy {
    public static void main(String[] args) {
//        创建接口实现类文件
//        第二个参数
        Class[] interfaces = {UserDao.class};
//        匿名类写法
//        Proxy.newProxyInstance(JDKProxy.class.getClassLoader(),
          interfaces, new InvocationHandler() {
//            @Override
//            public Object invoke(Object proxy, Method method, Object[] args)
          throws Throwable {
//                return null;
//            }
//        });
        UserDaoImp1 u = new UserDaoImp1();
        UserDao o = (UserDao) Proxy.newProxyInstance(JDKProxy.class.getClassLoader(), 
        interfaces, new UserDaoProxy(u));
        int a = o.add(1);
        System.out.println(a);
    }
}
//创建代理对象码
class UserDaoProxy implements InvocationHandler{
 
//    想要增强UserDaoImp1的代理对象，所以将UserDaoImp1传进来，这样才能将之前的方法和扩展的方法执行
//有参传递
//(可传UserDaoImp1 imp1）但object更通用,这部分实现的是之前要实现的方法
    private Object obj;
    public UserDaoProxy(Object obj){
this.obj = obj;
    }
//    增强逻辑
    @Override
//    proxy:代理对象  method :当前方法 args：参数
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
 
        System.out.println("方法之前执行"+method.getName()+"传递的参数"+ Arrays.toString(args));
//method.invoke()方法，用来执行某个的对象的目标方法。
//        被增强的方法执行,obj:对象 args：参数
        Object res = method.invoke(obj, args);
 
//        方法之后
        System.out.println("方法之后执行"+obj);
        return res;
    }
}

 invoke方法来委托动态构造的对应类型对象，使其执行对应形参的add方法，这是回调函数（方法）的功能。回调函数不是由该函数的实现方直接调用，而是在特定的事件或条件发生时由另外的一方调用的，用于对该事件或条件进行响应。

AOP术语
前置通知：比如我要执行add，方法之前执行

后置通知：方法之后执行

环绕通知：方法之前和之后都会执行

异常通知：发生异常执行

最终：相当于finally

切面：把通知应用到切入点guocheng。 比如在登录过程中加一个权限判断

AOP操作（准备）
1、Spring框架一般都是基于AspectJ实现AOP操作
       （1）什么是AspectJ
         AspectJ不是Spring组成部分，独立AOP框架，一般把AspectJ和Spring框架一起使用，进
        行AOP操作
 2、基于AspectJ实现AOP操作
        （1）基于xml配置文件实现
        （2）基于注解方式实现（使用）
3.在项目中引入aop所需要的jar包

Aop注解操作（AspectJ）
@Aspect:作用是把当前类标识为一个切面供容器读取

@Pointcut：Pointcut是植入Advice的触发条件。每个Pointcut的定义包括2部分，一是表达式，二是方法签名。方法签名必须是 public及void型。可以将Pointcut中的方法看作是一个被Advice引用的助记符，因为表达式不直观，因此我们可以通过方法签名的方式为 此表达式命名。因此Pointcut中的方法只需要方法签名，而不需要在方法体内编写实际代码。

@Around：环绕增强，相当于MethodInterceptor

@AfterReturning：后置增强，相当于AfterReturningAdvice，方法正常退出时执行

@Before：标识一个前置增强方法，相当于BeforeAdvice的功能，相似功能的还有

@AfterThrowing：异常抛出增强，相当于ThrowsAdvice

@After: final增强，不管是抛出异常或者正常退出都会执行

1.创建增强类（编写增强逻辑）

（1）在增强类里面，创建方法，让不同方法代表不同通知类型

package com.ye.advice;

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

//增强类
@Component
@Aspect//生成代理对象
public class Loger {
    // 前置通知
    @Before("execution(* *..BookSerice.*(..))")
//    要求：让这个方法比User类里的addfangfa之前执行：前置通知
//    被增强的方法
   public void cherk(){
       System.out.println("前置通知...执行系统的权限验证");
   }
    // 后置通知
   @AfterReturning("execution(* *..BookSerice.*(..))")
   public void logPrint(){
       System.out.println("后置通知...执行系统的权限验证");
   }
    //后置异常
    @AfterThrowing("execution(* *..BookSerice.*(..))")
    public void exception(){
        System.out.println("打印时出现错误");
    }
    //后置增强
    @AfterReturning("execution(* *..BookSerice.*(..))")
    public void distory(){
        System.out.println("打印成功");
    }
    //环绕增强
    @Around("execution(* *..BookSerice.*(..))")
    public void round(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
 System.out.println("环绕之前.");
        //该方法表示调用增强的方法
proceedingJoinPoint.proceed();
System.out.println("环绕之后");
}
}

After:无论是否有异常都输出

AfterReturning：有异常不输出

 2、进行通知的配置
    （1）在spring配置文件中，开启注解扫描
    （2）使用注解创建User和UseProxy对象
    （3）在增强类上面添加注解@Aspedt
    （4）在spring配置文件中开启生成代理对象

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

<!--开启注解扫描-->
    <context:component-scan base-package="com.java.aop"></context:component-scan>
 
<!--    开启Aspect生成代理对象，找到含有@Aspect注解的类将此类生成代理对象-->
    <aop:aspectj-autoproxy/>