Spring5学习

spring是一款轻量级、开源的JavaEE框架，可以解决企业应用开发的复杂性。
使用spring需要引入的依赖

<dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-expression</artifactId>
            <version>5.0.3.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.0.3.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>5.0.3.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>5.0.3.RELEASE</version>
        </dependency>
        <!--        spring需要依赖日志文件-->
        <dependency>
            <groupId>commons-logging</groupId>
            <artifactId>commons-logging</artifactId>
            <version>1.2</version>
        </dependency>

spring的两个特性（即spring的核心部分）
一、IOC控制反转，吧创建对象和对象之间的调用过程交给spring来管理，降低代码间的耦合度。
1、底层原理
（1）在xml文件中配置创建的对象
（2）工厂模式
（3）通过反射获取对象
2、IOC接口（BeanFactory）
IOC思想是基于IOC容器完成的，IOC容器底层就是对象工厂。
（1）BeanFactory：IOC容器的基本实现，是spring内部使用的接口，不提供开发人员使用，加载配置文件的时候不会创建对象，在获取（使用）该对象的时候创建。
（2）ApplicationContext：BeanFactory接口的子接口，提供更强大的功能，一般由开发人员进行使用，在加载配置文件的时候就会将配置文件中的对象进行创建。

3、IOC操作Bean（基于xml配置文件）‘
Bean管理指两个步骤：
创建对象：在xml文件里添加bean
注入属性：DI依赖注入（IOC的一种实现方式）
（1）通过无参构造方法注入

//创建bean
<bean id="student" class="com.zhang.entity.Student">
    <property name="name" value="张张"></property>
    <property name="gender" value="女"></property>
</bean>
//获取bean的实例
ApplicationContext context=new ClassPathXmlApplicationContext("bean1.xml");
Student student = context.getBean("student", Student.class);

（2）通过有参构造方法注入

<bean id="student" class="com.zhang.entity.Student">
    <constructor-arg name="name" value="张张"></constructor-arg>
    <constructor-arg name="gender" value="女"></constructor-arg>
</bean>

（3）p名称空间注入（了解即可）

<?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:p="http://www.springframework.org/schema/p"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    <bean id="student" class="com.zhang.entity.Student" p:name="张张" p:gender="女"></bean>
</beans>

（4）特殊值注入
如果再value中含有<>等特殊符号直接注入会报错，需要将符号转义或设置特殊符号

<bean id="student" class="com.zhang.entity.Student">
        <property name="name">
            <value><![CDATA[<张张>]]></value>
        </property>
        <property name="gender" value="女"></property>
    </bean>

（5）外部bean注入
类结构

<bean id="studentService" class="com.zhang.service.impl.StudentServiceImpl">
        <property name="studentDao" ref="studentDao"></property>
    </bean>
    <bean id="studentDao" class="com.zhang.dao.impl.StudentDaoImpl"></bean>

（6）内部bean注入

<!--    在Emp类里包含了以Dept类为属性的字段-->
<bean id="emp" class="com.zhang.entity.Emp">
        <property name="ename" value="张张"></property>
        <property name="gender" value="女"></property>
        <property name="dept">
            <bean id="dept" class="com.zhang.entity.Dept">
                <property name="dname" value="java开发"></property>
            </bean>
        </property>
    </bean>

（7）注入集合属性

<bean id="stu" class="com.zhang.entity.Stu">
        <property name="courses">
            <array>
                <value>线代</value>
                <value>高数</value>
            </array>
        </property>
        <property name="list">
            <list>
                <value>张张</value>
                <value>小张</value>
            </list>
        </property>
        <property name="map">
            <map>
                <entry key="JAVA" value="java"></entry>
                <entry key="PHP" value="php"></entry>
            </map>
        </property>
        <property name="set">
            <set>
                <value>mysql</value>
                <value>oracle</value>
            </set>
        </property>
        <property name="courseList">
            <list>
                <ref bean="course1"></ref>
                <ref bean="course2"></ref>
            </list>
        </property>
    </bean>
    <bean id="course1" class="com.zhang.entity.Course">
        <property name="cname" value="计网"></property>
    </bean>
    <bean id="course2" class="com.zhang.entity.Course">
        <property name="cname" value="操作系统"></property>
    </bean>

（8）把集合注入部分提取出来

<?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:util="http://www.springframework.org/schema/util"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
                           http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd">
    <util:list id="courseList">
        <value>线代</value>
        <value>高数</value>
    </util:list>
    <bean id="stu" class="com.zhang.entity.Stu">
        <property name="courses" ref="courseList"></property>
    </bean>
</beans>

（9）Bean类型
spring有两种bean，一种是普通bean，一种是工厂bean。
普通bean：在配置文件中定义的bean类型就是返回类型
工厂bean：在配置文件定义bean类型可以和返回类型不一样。

//创建作为工厂bean的类，实现接口FactoryBean，在实现的方法中定义返回的bean类型
public class MyBean implements FactoryBean<Courses> {
    @Override
    public Courses getObject() throws Exception {
        Courses courses=new Courses();
        courses.setCname("java");
        return courses;
    }

    @Override
    public Class<?> getObjectType() {
        return null;
    }
}
<bean id="courses" class="com.zhang.entity.MyBean"></bean>

（10）Bean的作用域
bean实例分为单实例和多实例，默认情况下bean是单实例对象。

//设置多实例，在调用getBean方法的时候才会创建多实例对象
<bean id="courses1" class="com.zhang.entity.MyBean" scope="prototype"></bean>
//设置单实例，在加载spring配置文件的时候就会创建单实例对象
<bean id="courses2" class="com.zhang.entity.MyBean" scope="singleton"></bean>

（11）Bean的生命周期
（1）通过构造器创建bean实例（无参构造）
（2）为bean的属性设置值和对其他bean引用（调用set方法）
（3）调用bean的初始化方法（需要进行配置初始化的方法）
（4）使用bean
（5）当日期关闭的时候，调用bean的销毁方法（需要进行配置销毁的方法）
（12）添加后置处理器
创建类实现接口BeanPostProcessor

public class MyPostBean implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("在初始化之前执行的方法");
        return null;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("在初始化之前执行的方法");
        return null;
    }
}

添加了后置处理器后的生命周期有七步
（1）通过构造器创建bean实例（无参构造）
（2）为bean的属性设置值和对其他bean引用（调用set方法）
（3）把bean实例传递到bean后置处理器的方法 postProcessBeforeInitialization
（4）调用bean的初始化方法（需要进行配置初始化的方法）
（5）把bean实例传递到bean后置处理器的方法 postProcessAfterInitialization
（6）使用bean
（7）当日期关闭的时候，调用bean的销毁方法（需要进行配置销毁的方法）
（13）自动装配
spring能根据指定的装配规则（根据名称或属性类型）

//byName需要属性名称和bean的id一样
<bean id="courses1" class="com.zhang.entity.MyBean" autowire="byName"></bean>
<bean id="courses1" class="com.zhang.entity.MyBean" autowire="byType"></bean>

（14）引入外部配置文件

<?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.xsd
                           http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
    <context:property-placeholder location="classpath:db.properties"></context:property-placeholder>
    <bean id="dateSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="url" value="${db.url}"></property>
        <property name="username" value="${db.username}"></property>
        <property name="password" value="${db.password}"></property>
        <property name="driver" value="${db.driver}"></property>
    </bean>
</beans>

4、IOC操作bean（基于注解方式）
使用spring的注解需要引入一个额外的jar包

<dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aop</artifactId>
            <version>5.0.3.RELEASE</version>
        </dependency>

（1）spring针对创建对象的注解
@Controller
@Service
@Repository
@Component
（2）spring针对属性注入的注解
@Autowired：根据属性类型进行自动装配
@Qualifier：根据属性名称进行注入，需要和@Autowired一起使用
@Resource：根据类型进行注入
@Value：注入普通类型属性

<?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.xsd
                           http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
    <!--配置扫描的包-->
    <context:component-scan base-package="com.zhang.service,com.zhang"></context:component-scan>
   <!-- <context:component-scan base-package="com.zhang" use-default-filters="false">
        <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
    </context:component-scan>-->
</beans>

5、使用完全注解的方式

@Configuration
@ComponentScan(basePackages = {"com.zhang"})
public class SpringConfig {
}
@Test
    public void test02(){
        ApplicationContext context=new AnnotationConfigApplicationContext(SpringConfig.class);
        UserService userServiceImpl = context.getBean("userServiceImpl", UserService.class);
        userServiceImpl.add();
    }

二、AOP切面编程，能在不修改原有代码的基础上增加功能
1、底层原理
（1）有接口的情况下，使用JDK动态代理（创建接口实现类代理对象）

//创建代理对象
class BookDaoProxy implements InvocationHandler {
    Object obj;

    public BookDaoProxy(Object obj) {
        this.obj = obj;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("方法执行之前："+method.getName()+"方法参数："+ Arrays.toString(args));
        Object res = method.invoke(obj, args);
        System.out.println("方法执行之后");
        return res;
    }
}
//使用Proxy创建接口代理对象
public class JDKProxy {
    public static void main(String[] args) {
        Class[] interfaces={BookDao.class};
        BookDaoImpl bookDao=new BookDaoImpl();
        BookDao dao= (BookDao) Proxy.newProxyInstance(JDKProxy.class.getClassLoader(),interfaces,new BookDaoProxy(bookDao));
        int add = dao.add(1, 2);
        System.out.println(add);
    }
}

（2）没有接口的情况下使用CGLIB动态代理（创建当前类子类的代理对象）
2、AOP术语
（1）切入点：类里面实际被增强的方法
（2）切面：把通知应用到切入点过程
（3）通知：实际增强的逻辑部分
（4）连接点：类里面哪些方法可以被增强，这些被增强的方法成为连接点
3、切入点表达式
execution（[权限修饰符][返回类型][类全路径][方法名称][参数列表]）
增强某个方法
execution(* com.zhang.dao.BookDao.add(…))
增强某个类
execution(* com.zhang.dao.BookDao.(…))
增强某个包下的类
execution( com.zhang.dao..(…)
4、注解配置aop操作

<?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.zhang.aopanno"></context:component-scan>
<!--    开启Aspect生成代理对象，只要在类上加了@Aspect注解就会生成对象-->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
</beans>

@Component
@Aspect
public class UserProxy {
    @Before("pointDemo()")
    public void before(){
        System.out.println("before....");
    }
    @After("pointDemo()")
    public void after(){
        System.out.println("after....");
    }
    @AfterReturning("pointDemo()")
    public void afterReturn(){
        System.out.println("afterReturn....");
    }
    @AfterThrowing("pointDemo()")
    public void afterThrowing(){
        System.out.println("AfterThrowing....");
    }
    @Around("pointDemo()")
    public void around(ProceedingJoinPoint point) throws Throwable {
        System.out.println("环绕之前");
        point.proceed();
        System.out.println("环绕之后");
    }
    @Pointcut("execution(* com.zhang.aopanno.User.add(..))")
    public void pointDemo(){

    }
}

5、xml文件配置aop操作

<?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">
    <bean id="dog" class="com.zhang.aopxml.Dog"></bean>
    <bean id="dogProxy" class="com.zhang.aopxml.DogProxy"></bean>
    <aop:config>
<!--        切入点-->
        <aop:pointcut id="p" expression="execution(* com.zhang.aopxml.Dog.eat(..))"/>
<!--        切面-->
        <aop:aspect ref="dogProxy">
            <aop:before method="before" pointcut-ref="p"></aop:before>
        </aop:aspect>
    </aop:config>
</beans>