Spring

创建的类在spring 中的生命周期， 控制权限交给了spring处理，抛弃了之前手动创建对象和实例对象。

 bean容器： 一个对象被创建和被实例化的过程发生的事。
 
 myclass --> 推断构造器 --> 初始化前 --> 初始化中 --> 初始化后 --> 代理对象aop --> （IOC bean）单例池 --> Bean对象

spring的特性：

​ 控制反转 inversion of control ： 指将对象的创建权力交给spring控制，每个对象称为bean

​ 依赖注入 dependency injection : 依赖的对象不需要手动调用setxxx方法去设置，而是通过配置赋值

​ 面向切面编程 aspect oriented programming : 在spring初始化实例对象前，通过切面设置，可以执行指定的切面方法。

​ spring容器： spring它是一个容器，我们的对象的生命周期在spring容器中控制着。

​ 组件化：使用简单的组件配置组合成一个复杂的应用。在 Spring 中可以使用XML和Java注解组合这些对象。

​

其他概念：

​ 单例： 一个类只有一个实例对象，实例化对象后将提供整系统使用。 bean是单例池，在多线程中，每个bean对象都只能存在一个单线中！

​ 同步机制：

​ ThreadLocal和线程同步机制相比有什么优势呢？他们都是为了解决多线程中相同变量的访问冲突问题。在同步机制中，通过对象的锁机制保证同一时间只有一个线程访问变量。这时该变量是多个线程共享的，使用同步机制要求程序慎密地分析什么时候对变量进行读写，什么时候需要锁定某个对象，什么时候释放对象锁等繁杂的问题，程序设计和编写难度相对较大。

概括起来说，对于多线程资源共享的问题，同步机制采用了“以时间换空间”的方式，而ThreadLocal采用了“以空间换时间”的方式。前者仅提供一份变量，让不同的线程排队访问，而后者为每一个线程都提供了一份变量，因此可以同时访问而互不影响。

​

spring核心：

1 控制反转 inversion of control

为什么要使用控制反转：

bean对象变得灵活，应用对象的创建的权力交给spring管理，用户可以通过spring容器获取应用对象。

减少耦合度

实现的方式有哪些？

依赖注入DI:

​ 构造函数的依赖注入

​ 设值函数的依赖注入

​ 注入内部beans

​ 注入集合

推断构造方法（默认的无参构造法）

Setter方法注入

使用xml配置应用对象

1.1 Bean

定义： bean是一个被实例化组装，通过springioc管理的对象，并由容器提供的配置 元数据 创建的。

bean的属性参数：

配置bean元数据的方式：

• 基于 XML 的配置文件
• 基于注解的配置
• 基于 Java 的配置

bean的后置处理器

在初始化bean的前后对bean进行其他处理

如何做后置处理：

​ 继承BeanPostProcessor 接口 实现初始化 前和初始化后方法。

public class InitHelloWorld implements BeanPostProcessor {
   public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
      System.out.println("BeforeInitialization : " + beanName);
      return bean;  // you can return any other object as well
   }
   public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
      System.out.println("AfterInitialization : " + beanName);
      return bean;  // you can return any other object as well
   }
}

bean的作用域

通过配置xml 中的 scope 指定哪种作用域

基于xml配置bean对象

<?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
    http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">

   <bean id="" class="" 
      scope="">
   </bean>

</beans>

import

当有多个bean.xml配置文件时，可以通过总的application.xml文件用Import到管理多个bean.xml文件

application.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
    http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">

    <import resource="bean.xml"/>
    <import resource="bean1.xml"/>


</beans>```

2 依赖注入

​ 给bean对象赋值元数据，元数据可以是引用class （注入内部Bean），有参构造方法，普通元数， 集合等复杂的数据赋值。

基本注入

2.1 有参构造方法

2.2 内部Bean注入

2.3 普通参数注入

2.4 集合参数注入

​ set , map ,array , 属性propr, null

类元数据
	private String beanname;
    private BeanLife beanLife; //内部Bena注入
    //集合注入
    private Set<String> setdi;
    private Map<String,String> mapdi;
    private String[] arrayListdi;
    private String nulldi;
    private Properties propertiesdi;

<?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
    http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
    内部bean
    <bean id="beanLife" class="spring.bean.BeanLife"/>

    <bean id="beanDI" class="spring.bean.BeanDI">
        <!--基本参数-->
       <property name="beanname" value="hellobean"/>

        <!-- 内部bean-->
        <property name="beanLife" ref="beanLife"/>

        <!-- 集合-->
        set
        <property name="setdi">
            <set>
                <value>set值</value>
                <value>set值1</value>
            </set>
        </property>
        map
        <property name="mapdi">
           <map>
               <entry key="用名" value="root"></entry>
               <entry key="密码" value="root"></entry>
           </map>
        </property>
        数组
        <property name="arrayListdi">
            <array>
                <value>西县及</value>
                <value>数组类型</value>
            </array>
        </property>
        null
        <property name="nulldi">
            <null/>
        </property>
        
        属性propety
        <property name="propertiesdi">
            <props>
                <prop key="one">INDIA</prop>
                <prop key="two">Pakistan</prop>
                <prop key="three">USA</prop>
                <prop key="four">USA</prop>
            </props>
        </property>



    </bean>

</beans>

简化注入

2.5 p 标签注入

xmlns:p="http://www.springframework.org/schema/p" 引入

属性命名空间注入
传统的属性参数 property name = "pname" value ="valuename"  ===  p:pname="valuename"

<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:p="http://www.springframework.org/schema/p"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd">
	传统属性注入
    <bean name="classic" class="com.example.ExampleBean">
        <property name="email" value="someone@somewhere.com"/>
    </bean>
	
    p命名注入
    <bean name="p-namespace" class="com.example.ExampleBean"
        p:email="someone@somewhere.com"/>
    
    注入的是内部bean对象时   p:spouse-ref
	    <bean name="classic" class="com.example.ExampleBean" 
              p:name = "Jane Doe" p:spouse-ref = "user"
              >
         <bean name="user" class="com.example.User">
            <property name="name" value="Jane Doe"/>
        </bean>     

</beans>

2.6 c 标签注入

配置有参构造函数参数注入

xmlns:c="http://www.springframework.org/schema/c"

<!--    使用c p 标签简化注入-->
 <bean id="userBean" class="spring.bean.UserBean" p:beanname="helloUserBean" c:beanname="有参构造"/>

2.7 depends-on

用来指定多个内部bean对象

depends-on 属性既可以指定初始化时间依赖，也可以指定对应的销毁时间依赖（仅在单例 bean 的情况下）。 与给定 bean 定义依赖关系的依赖 bean 首先被销毁，在给定 bean 本身被销毁之前。 因此，depends-on 也可以控制关闭顺序。

<bean id="beanOne" class="ExampleBean" depends-on="bean1,bean2">
    <property name="manager" ref="manager" />
</bean>

<bean id="bean1" class="ManagerBean" />
<bean id="bean2" class="x.y.jdbc.JdbcAccountDao" />

3.自动装配 autowired

没有自动装配之前，我们用xml配置内部Bean对象属性，通过 ref 或者p标签 p:spouse-ref，引入内部Bena的元数据。

现在用自动装配 autowired="byName/byType" ，自己去容器找到内部类的属性名和类型。

byName：内部bean对象属性名

byType： 内部bean对象数据类型

	<!--    自动装配-->
	两个内部类
    <bean id="man" class="spring.bean.userclass.Man"/>
    <bean id="gegir" class="spring.bean.userclass.Gegir"/>

	bean对象
    <bean id="proson"  class="spring.bean.userclass.Proson" p:name="人们" autowire="byType">

    </bean>

构造函数的自动装配 constructor-arg

<!--    自动装配-->
    <bean id="man" class="spring.bean.userclass.Man"/>
    <bean id="gegir" class="spring.bean.userclass.Gegir"/>

    <bean id="proson"  class="spring.bean.userclass.Proson" p:name="人们" autowire="constructor">
        <constructor-arg value="这是man构造函数"/>
        <constructor-arg value="这是gegir构造函数"/>
    </bean>

4.面向切面AOP

面向切面是基于动态代理的反射机制，通过创建代理对象，可以将方法切入到指定目标类方法前后，或者环绕，或者抛异常

创建aop的方法有哪些

1. 原生的spring api

2. 基于 bean.xml 配置文件

3. 基于注解

什么是切面（<aop:aspect ref="日志类"> 自定义的切入面）

​ 切入目标类的，代理类

什么是切点（expression="execution(* aop.serve.UserServceImp.*(..))）又是实现类

​ 切入点是被代理类的方法执行的目标类

每个类执行完方法之前和之后切入面类的方法就会根据应用场景来执行你方法的前后通知

依赖Spring5的AOP依赖

   <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.2</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.2.1.RELEASE</version>
        </dependency>

基于xml配置实现AOP

场景：

​ 我有一个数据库操作的业务类，它继承了userDao并实现增删改查方法，userDaoImp继承类执行sql的业务操作。 我想在执行sql操作的前后都加一个通过，执行中，和执行完成

UserDao.interface

package aop.dao;

public interface UserDao {
    public void add();
    public void delete();
    public void update();
    public void select();
    public void insert();
}

UserServceImp.class

package aop.serve;


import aop.dao.UserDao;

public class UserServceImp implements UserDao {
    @Override
    public void add() {
        System.out.println("执行添加操作");
    }

    @Override
    public void delete() {
        System.out.println("删除");
    }

    @Override
    public void update() {
        System.out.println("更新");
    }

    @Override
    public void select() {
        System.out.println("查询");
    }

    @Override
    public void insert() {
        System.out.println("插入");
    }

}

切面类Logger.class

public class Logger {

    public void befor(){
        System.out.println("正在执行操作！");
    }
    public void after(){
        System.out.println("执行完成！");
    }
    
 }

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

    注入bean对象
    <bean id="userServceImp" class="aop.serve.UserServceImp"/>
    <bean id="logger" class="aop.log.Logger"/>
    
    
    配置aop
    <aop:config>

        <!--自定义的日志切面-->
        <aop:aspect ref="logger">
            <aop:pointcut id="pointcut" expression="execution(* aop.serve.UserServceImp.*(..))"/>
            <aop:before method="befor" pointcut-ref="pointcut"/>
            <aop:after method="after" pointcut-ref="pointcut"/>
        </aop:aspect>

    </aop:config>
    
    
    
</beans>

execution( * * * * ) 五个 * 号所代表的含义

execution( 返回值类型 切点类路径 子包 所有类 所有方法)

Spring注解

一 IOC注解

简化之前的bean.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
    http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
    http://www.springframework.org/schema/context
    http://www.springframework.org/schema/context/spring-context-3.0.xsd">
    
    开启注解模式
   <context:annotation-config/>

 

</beans>

Bean （@component ）

@Component

等价于 xml 中的标签 ，指定名称用 @component("user") ===

开启组件扫描
<context:component-scan  base-package=“扫描包下带有component的类”/>

生命周期

​

作用域@Scope

@Scope（“singleton”）：单例模式
@Scope（“prototype”）：多例模式

依赖注入

普通参数的依赖注入@Value

注入集合

构造函数的注入

内部Bean对象的注入

自动装配 @Autowired @Resource

解决内部bean对象的byName属性名和byType类型，构造方法等元数据

@Resource
private Man man;
@Autowired
private Gegir gegir;

<!--    开启注解模式-->
    <context:annotation-config/>
	autowired注解
    <bean id="gegir1" class="spring.bean.userclass.Gegir"/>

	resouce注解 javax自带的
    <bean id="man" class="spring.bean.userclass.Man"/>
    <bean id="man2" class="spring.bean.userclass.Man"/>

    <bean id="proson" class="spring.bean.userclass.Proson"/>

@Autowired @Resourc的区别

1. 功能相同都是用来自动装配的，都可以放在内部bean对象上
2. @Autowired通过byname方法来实现
3. @Resourc通过byname方法来实现，如果找不到属性名，则通过byType实现

其他注解

JSR250

bean的初始化 @PostConstruct 注释作为初始化回调函数的一个替代，

bean的销毁 @PreDestroy 注释作为销毁回调函数的一个替代

@Required 注解应用于 bean 属性的 setter 方法**

@Qualifier 指定bean.xml中使用的是哪某个beans对象

package com.tutorialspoint;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
public class Profile {
   @Autowired
   @Qualifier("student1")  指定bean.xml另外的byName值
   private Student student;
   public Profile(){
      System.out.println("Inside Profile constructor." );
   }
   public void printAge() {
      System.out.println("Age : " + student.getAge() );
   }
   public void printName() {
      System.out.println("Name : " + student.getName() );
   }
}

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

   <context:annotation-config/>

   <!-- Definition for profile bean -->
   <bean id="profile" class="com.tutorialspoint.Profile">
   </bean>

   <!-- 同个byTpye 不同byName -->
   <bean id="student1" class="com.tutorialspoint.Student">
      <property name="name"  value="Zara" />
      <property name="age"  value="11"/>
   </bean>

   <bean id="student2" class="com.tutorialspoint.Student">
      <property name="name"  value="Nuha" />
      <property name="age"  value="2"/>
   </bean>

</beans>

​

二 AOP注解

切点@Pointcut("execution(* 目标类路径 *(..))")

切面@Aspect

前置通知 @Before

后置通知 @After

环绕通知 @Around

最后环绕通知 @AfterReturning(pointcut = "", returning="返回值")

异常通知 @AfterThrowing(pointcut = "", throwing = "抛异常的参数")

实现

注入bean

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

    <!--开启切面注解-->
    <aop:aspectj-autoproxy/>

    切面
    <bean id="aLogger" class="aop.annotation.ALogger"/>
    切点
    <bean id="aUserDaoImp" class="aop.annotation.AUserDaoImp"/>



</beans>

日志注解切面

package aop.annotation;


import org.aspectj.lang.annotation.*;

@Aspect
public class ALogger {
	
    单独抽取指向切点的方法供其他切面方法使用
    @Pointcut("execution(* aop.annotation.AUserDaoImp.*(..))")
    public void selecall(){}

    @Before("selecall()")
    public void befor(){
        System.out.println("执行之前！");
    }

    @After("selecall()")
    public void after(){
        System.out.println("执行之后！");
    }

    public void aroutd(){ System.out.println("在方法之前之后，环绕通知");}
    public void afterreturning(){
        System.out.println("afterreturning");
    }

    @AfterThrowing(pointcut = "selecall()", throwing = "E")
    public void throwing(IllegalArgumentException  E){
        System.out.println("throwing"+ E.toString());
    }


}

切点

import org.springframework.stereotype.Component;

@Component
public class AUserDaoImp implements AUserDao{
    @Override
    public void add() {
        System.out.println("执行添加操作");
    }

    @Override
    public void delete() {
        System.out.println("删除");
    }

    @Override
    public void update() {
        System.out.println("更新");
    }

    @Override
    public void select() {
        System.out.println("查询");
    }

    @Override
    public void insert() {
        System.out.println("插入");
    }
}

Spring使用的注解大全和解释