Spring入门。

程序的耦合和解耦。

1、问题引入。

在使用jdbc和数据库交互时。注册驱动：DriverManager.registerDriver(new com.mysql.cj.jdbc.Driver());
如果把mysql的依赖（jar包）删掉，那么程序在编译期就会出现错误。也就是说当前类，依赖于Driver类。

2、程序的耦合。

耦合：简单来说，就是程序间的依赖关系。包括：类之间的依赖、方法之间的依赖。

解耦：降低程序间的依赖关系。

实际开发中应做到：编译期不依赖，运行时才依赖。

之前注册驱动时，一直用的是  Class.forName("com.mysql.cj.jdbc.Driver")。它依赖的只是一个字符串。

所以，

解耦的思路：

　　* 第一步：使用反射来创建对象，而 避免使用new关键字。

　　　　问题：这样的话，字符串写死了，如果以后用其他数据库驱动，需要改源码。

　　* 第二部：通过读取配置文件来获取要创建的对象全类名。

3、另一个问题。

通过分析，在之前的三层架构中，各个层之间的调用也有很大的耦合问题。

解决方案：工厂模式解耦。

　　创建一个 创建Bean对象的工厂。

　　Bean：代表可重用组件的含义。

　　JavaBean：用Java编写的可重用组件。JavaBean > 实体类。

　　第一：需要一个配置文件来配置service和dao。配置的内容：唯一标识=全类名。

　　第二：通过读取配置文件的内容，反射创建对象。

public class BeanFactory {
    private static Properties properties;
    static {
        properties=new Properties();
        InputStream is=BeanFactory.class.getClassLoader().getResourceAsStream("beanfactory.properties");
        try {
            properties.load(is);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    public static Object getBean(String beanName) {
        Object bean=null;
        String beanPath=properties.getProperty(beanName);
        try {
            bean=Class.forName(beanPath).newInstance();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        return bean;
    }

}

由于这句代码的存在 bean=Class.forName(beanPath).newInstance();  导致每次用的时候都会创建一个新的对象。

改进方法：将对象先创建完，存入集合中，用的时候直接在集合中拿。、

改进后的工厂模式：

public class BeanFactory {
    private static Properties properties;
    private static Map<String,Object> beans;
    static {
        properties=new Properties();
        InputStream is=BeanFactory.class.getClassLoader().getResourceAsStream("beanfactory.properties");
        try {
            properties.load(is);
            beans =new HashMap<String, Object>();
            Enumeration keys = properties.keys();
            while (keys.hasMoreElements()){
                String key=keys.nextElement().toString();
                String beanPath=properties.get(key).toString();
                Object value=Class.forName(beanPath).newInstance();
                beans.put(key,value);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    public static Object getBean(String beanName) {
       return beans.get(beanName);
    }

}

private AcountDao dao=new AcountDaoImp();

private AcountDao dao=(AcountDaoImp)BeanFactory.getBean("AcountDao");

这两种获取对象的形式上，第一种，应用程序直接依赖于资源。而第二种，利用工厂消除了应用程序和资源的直接依赖关系。

第二种方法的思想，就是IOC。

为什么叫控制反转，不叫降低依赖？

　　因为，对于应用程序来说，用第一种方式创建对象时，有自己的独立控制权，想要谁就要谁，而第二种方式，应用程序失去了控制器，把控制权交给了工厂和配置文件。这种控制权发生的转移，就是控制反转。

Spring的IOC和DI。

控制反转（Inversion of Control，IOC）把创建对象的权力交给框架，是框架的重要特征。

IOC的作用：削减计算机程序的耦合。

Spring基于xml的IOC的环境搭建：

　　1、导入依赖。

　　2、配置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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd">
    <bean id="AcountDao" class="AcountDao.AcountDaoImp"></bean>
    <bean id="AcountService" class="AcountService.AcountServiceImp"></bean>
</beans>

　　3、主程序。

 public static void main(String[] args) {
         //1、获取核心容器对象
        ApplicationContext ac=new ClassPathXmlApplicationContext("bean.xml");
         //2、根据id获取Bean对象
        AcountService acountService=(AcountService)ac.getBean("AcountService");
        AcountDao acountDao=ac.getBean("AcountDao",AcountDao.class);
        System.out.println(acountService);
        System.out.println(acountDao);

    }

ApplicationContext 的三个常用实现类。

　　1、ClassPathXmlApplicationContext:它可以加载类路径下的配置文件，要求配置文件必须在类路径下。

　　2、FileSystemXmlApplicationContext：它可以加载任意路径下的配置文件。

　　3、AnnotationConfigApplicationContext：用于注解创建容器。

核心容器的两个接口。

　　1、ApplicationContext：它在构建核心容器时，创建对象采用的策略是立即加载的方式，也就是说，只要一读取完配置文件，马上就创建对象。

　　2、BeanFactory：它采用延迟加载的方式，什么时候需要，什么时候创建对象。

Spring对Bean的管理细节。

　　1、创建bean 的三种方式。

　　　　* 使用默认构造函数创建：在spring配置文件中使用bean标签，配以id和class属性，且没有其他属性和标签时，采用的就是默认构造函数创建bean对象，此时如果类中没有默认构造函数，则无法创建。

　　　　* 使用普通工厂的方法创建对象（使用某个类的方法创建其他类对象）：在bean标签中使用 factory-bean和factory-method 属性指定类和方法。

　　　　* 使用工厂的静态方法创建对象（使用某个类的静态方法创建对象）：使用class和factory-method属性。

　　2、Bean的作用范围。

　　　　bean标签的scope属性取值：

　　　　　　* singleton：单例的（默认值） 常用

　　　　　　* prototype：多例的。常用

　　　　　　* request：作用于web应用的请求范围。

　　　　　　* session：作用于web应用的会话范围。

　　　　　　* global-session：作用于集群环境的会话范围。

　　3、Bean对象的生命周期。

　　　　* 单例对象。

　　　　　　出生：当容器创建时对象出生。

　　　　　　活着：只要容器存在，对象就一直存在。

　　　　　　死亡：容器销毁，对象销毁。

　　　　　　总结：单例对象的生命周期和容器相同。

　　　　* 多例对象。

　　　　　　出生：要使用对象时创建。

　　　　　　活着：对象 只要在使用过程中就一直活着。

　　　　　　死亡：对象长时间不用，且没有被引用时，由jvm回收。

Spring中的依赖注入。

IOC的作用：降低程序间的依赖关系（耦合）

依赖关系的管理：以后都交给spring来维护。

在当前类需要用到其他类的对象时，由spring为我们提供，我们只需在配置文件中说明。

依赖关系的维护就称之为依赖注入。

依赖注入：

　　1、能注入的数据，有三类：

　　　　*基本类型和String

　　　　*其他bean类型（在配置文件中或注解配置过的bean）

　　　　*复杂类型/集合类型

　　2、注入的方式，有三种：

　　　　第一种：使用构造函数提供

　　　　　　使用的标签：constructor-arg

　　　　　　标签的位置：bean里

　　　　　　标签中的属性：

　　　　　　　　* type：指定注入数据的类型，也是构造函数中参数的类型。

　　　　　　　　* index：要注入的数据在构造函数中的位置。

　　　　　　　　* name：构造函数中指定参数。

　　　　　　　　* value：用于提供基本类型和String类型的数据。

　　　　　　　　* ref：用于指定其他的bean类型数据。

<bean id="AcountService" class="AcountService.AcountServiceImp">
        <constructor-arg name="name" value="rt"></constructor-arg>
        <constructor-arg name="age" value="21"></constructor-arg>
        <constructor-arg name="birthday" ref="birthday"></constructor-arg>
    </bean>
    <bean id="birthday" class="java.util.Date"></bean>

　　　　　　优势：获取bean对象时，注入数据是必须的操作。

　　　　　　弊端：改变了bean对象的实例化方式，如果创建对象时用不到这些数据，也必须提供。

　　　　第二种：使用set方法提供    更常用

　　　　　　涉及的标签：property

　　　　　　出现的位置：bean里

　　　　　　标签的属性：

　　　　　　　　* name：指定注入时所调用的set方法名称。

　　　　　　　　* value：用于提供基本类型和String类型的数据。

　　　　　　　　* ref：用于指定其他的bean类型数据。

　　　　　　优势：创建对象时没有明确的限制，可以直接使用默认的构造函数。

　　　　　　弊端：如果某个成员必须有值，则获取对象时有可能set方法没有执行。

　　　　　　复杂类型/集合类型的注入：

　　　　　　　　*用于给list结构的集合注入的标签：list   arry  set

　　　　　　　　*用于给map结构的集合注入的标签：map  props

　　　　第三种：使用注解提供

　　　　　　用于创建对象的注解： 它们的功能和<bean>标签实现的功能一样

　　　　　　　　1、@Component：把当前类对象存入spring容器中。

　　　　　　　　属性：value：用于指定bean的id。默认是当前类名，且首字母小写。

　　　　　　　　2、@Controller：一般用于表现层

　　　　　　　　3、@Service：一般用在业务层

　　　　　　　　4、@Repository：一般用在持久层

　　　　　　　　以上三个注解的作用和@Componet一样，是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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        https://www.springframework.org/schema/context/spring-context.xsd">

    <!--告知spring在创建容器时要扫描的包，配置所需的标签不是在beans的约束中，而是
    一个名称为context名称空间和约束中-->
    <context:component-scan base-package="AcountService"></context:component-scan>

</beans>

　　　　　　用于注入数据的注解：它们的作用和bean中的<property>标签的作用一样

　　　　　　　　1、@Autowired：

　　　　　　　　　　* 作用：自动按类型注入。

　　　　　　　　　　　　　　* 只要容器中有唯一的一个bean对象类型和要注入的变量类型匹配，就可以成功注入。

　　　　　　　　　　　　　　* 如果ioc容器中没有任何bean的类型和要注入的变量类型匹配，则报错。

　　　　　　　　　　　　　　* 如果ioc容器中有多个匹配的类型时，在将变量名作为bean的id，继续查找匹配项。

　　　　　　　　　　* 出现位置：变量上，或者方法上。

　　　　　　　　2、@Qualifier：

　　　　　　　　　　* 作用：在按照类型注入的基础上再按照名称注入。它在给类成员注入时不能单独使用（需要AotoWired）。但是在给方法参数注入时可以。

　　　　　　　　　　* 属性：value：用于指定注入bean的id。

　　　　　　　　3、@Resource：

　　　　　　　　　　* 作用：直接按照bean的id注入，可以单独使用。

　　　　　　　　　　* 属性：name：bean的id。

　　　　　　　　4、@Value：

　　　　　　　　　　* 作用：用于注入基本类型和String类型的数据。

　　　　　　　　　　* 属性：value：用于指定数据的值。可以使用spring的SpEL表达式。${表达式}

　　　　　　用于改变作用范围的注解：它们的作用和bean中的scope属性作用一样

　　　　　　　　1、@Scope：

　　　　　　　　　　* 作用：指定bean的作用范围。

　　　　　　　　　　* 属性：value：指定范围的取值：singleleton   prototype

　　　　　　和生命周期相关的注解：它们的作用和bean中的init-method  和 destroy-method  属性的作用一样

　　　　　　　　1、@PreDestroy

　　　　　　　　　　* 作用：用于指定销毁方法

　　　　　　　　2、@PostConstruct

　　　　　　　　　　* 作用：用于指定初始化方法

Spring中的新注解：

虽然上面的描述中已经使用了注解来配置，但是任然需要xml文件。

解决方案：创建一个配置类。

　　1、@Configuration

　　　　* 作用：指定当前类是一个配置类。

　　2、@ComponetScan

　　　　* 作用：指定spring在创建容器时需要扫描的包

　　　　* 属性：value：它和basePackeages的作用一样，都用于指定创建容器时需要扫描的包，相当于xml的：<context:component-scan base-package="AcountService"></context:component-scan>

　　3、@Bean

　　　　* 作用：将当前方法的返回值作为bean对象存入ioc容器。

　　　　* 属性：name：指定bean 的id，默认是方法名称。

　　　　* 细节：使用注解配置方法时，如果方法有参数，spring会在容器中查找有没有可用的bean对象，查找方式和Aoutowired一样。

　　4、@Import

　　　　* 作用：用于导入其他配置类。

　　　　* 属性：value：指定其他配置类的字节码。、

　　　　   使用Import注解的类是父配置类，导入的是子配置类。

　　5、@PropertySource

　　　　* 作用：用于指定properties文件的位置。

　　　　* 属性：value：文件的名称和路径。 关键字：classpath：表示类路径下。

Spring整合Junit的配置。

　　1、导入jar坐标。

　　2、使用Junit提供的一个注解把原有的main方法替换成spring提供的。

　　　　@Runwith(SpringJUnit4ClassRunner.clsss)

　　3、告知spring的运行器，spring和ioc创建是基于xml还是基于注解，且说明位置。

　　　　@ContextConfiguration

　　　　　　location:指定xml文件的位置，加上classpath，表示在类路径下。

　　　　　　classes：指定注解类所在位置。

　　当使用spring5.x时，要求junit必须是4.12及以上。

AOP：

动态代理:

　　特点:字节码随用随创建,随用随加载.

　　作用:不修改源码的基础上对方法增强.

　　分类:基于接口的动态代理   基于子类的动态代理.

　　基于接口的动态代理:

　　　　1.涉及的类:Proxy

　　　　2.提供者:JDK

　　　　3.如何创建代理对象:newProxyInstance方法.

　　　　4.创建代理对象的要求:被代理类最少实现一个接口.

　　　　5.newProxyInstance方法的参数:

　　　　　　* ClassLoader:类加载器. 用于加载代理对象的字节码,和被代理对象使用相同的类加载器. 固定写法.

　　　　　　* Class[] :字节码数组. 用于让代理对象和被代理对象有相同的方法. 固定写法.

　　　　　　* InvocationHandler: 用于提供增强的代码. 它是让我们写如何代理. 一般都是写一个该接口的实现类,通常是匿名内部类,但不是必须的.

　　　　6.invoke方法的作用: 执行被代理对象的任何接口方法都经过改方法(拦截作用)

　　　　7.invoke方法的参数:

　　　　　　* proxy:代理对象的引用.

　　　　　　* method: 当前执行的方法.

　　　　　　* args :当前执行方法所需的参数.

　　　　　　* 返回值: 和被代理对象方法有相同的返回值.

问题引入：

　　在转账案例中，分析可知，应该使用ThreadLocal对象把Connection和当前线程绑定，从而使一个线程只能有一个能控制事务的对象。

AOP概述：

AOP：Aspect Oriented Programming 。面向切面编程。

作用：在程序运行期间，不修改源码对已有的方法进行增强。

优势：减少重复代码，提高开发效率，维护方便。

实现方式：动态代理。

Spring中的AOP：spring中的AOP就是通过配置的方式，实现AOP功能　。

　　1、引入依赖。

　　2、开启基于注解的AOP功能<aop:aspectj-autoproxy>

　　3、写切面类（重复的模块），并用存入容器，@Component ，以及声明为切面类 @Aspect

　　4、申明切面类的各种通知（方法）是什么时候执行（@before....)，然后声明在切入哪个方法（切入点表达式）：@before（“execution（修饰符 返回值 方法全类名）”）。可以在通知方法中声明类型为 JoinPoint的参数，用来访问被代理方法的参数。

AOP中的细节：

　　1、有接口时，使用的对象并非原对象，而是代理对象，它们之间唯一的关系是实现了同一个接口，所以要用接口类型来接收。没有接口时，用的是cglib创建的代理对象，可以用原对象来接收。

　　2、切入点表达式：

　　　　i：可以使用通配符：*  ：1、匹配任意字符 Mymethod* ：以Mymethod开头的所有方法。  2、匹配任意一个参数（int ,*) 一个int  一个任意。

　　　　　　　　　　　　　.. ：1、匹配任意个参数（..)  2、匹配任意多层路径  com.sicau..mymethod(..)

　　3、切入方法执行顺序：正常：@before @after（finally里面）  @afterreturnning（方法返回后） 异常：@before @after（finally里面） @afterthrowing

　　4、可以使用JoingPoint  获取当前执行方法对象。

　　5、通知方法的格式要求是不严谨的，唯一要注意的是，参数不能乱写，因为最终方法是由spring调用，它要知道具体参数是什么，比如你要获得异常，需要在注解上申明：throwing=变量名。

　　6、抽取可重用的切入点表达式：随便申明一个void 方法 ，方法加@PointCut（表达式），引用：直接用方法名引用。

　　7、环绕通知，通知上加@Around，它就是一个动态代理，ProceedingJoinPoint 对象.proceed ，就是相当于invoke方法，可以在方法周围写通知。

　　8、环绕通知在普通通知之前执行，因为普通通知是在proceed方法执行后才能执行的。

　　9、多个切面同时作用时，可以使用@Order ，数字越小，越优先执行，执行过程相当于嵌套过程。

Spring中的事务：

　　1、事务回滚：默认发生运行时异常会回滚，但但发生编译时异常不会回滚。@Translational 中的属性：norollbackfor={class} 哪些异常可以不回滚。rollbackfor={class} 哪些异常要回滚。

　　2、事务传播行为：事务里有其他事务时，  propagation=Propagation.Require    使用当前事务    propagation=Propagation.Require_new  使用新事务。

　　　　　　使用require时，事务的属性都是继承大事务的，自己设的属性无效。