1. Spring框架学习

1.1 Spring介绍

Spring框架是一个开放源代码的J2EE应用程序框架，由Rod Johnson发起，是针对bean的生命周期进行管理的轻量级容器（lightweight container）。
Spring解决了开发者在J2EE开发中遇到的许多常见的问题，提供了功能强大IOC、AOP及Web MVC等功能。Spring可以单独应用于构筑应用程序，也可以和Struts、Webwork、Tapestry等众多Web框架组合使用，并且可以与 Swing等桌面应用程序AP组合。因此， Spring不仅仅能应用于JEE应用程序之中，也可以应用于桌面应用程序以及小应用程序之中。Spring框架主要由七部分组成，分别是 Spring Core、 Spring AOP、 Spring ORM、 Spring DAO、Spring Context、 Spring Web和 Spring Web MVC。
知识补充:
1.J2SE java基础 J2EE java企业级开发 J2ME 移动端开发
2. bean: spring容器管理的对象称之为bean
3. 生命周期: 对象创建/对象的初始化/对象执行业务逻辑/对象销毁
4. 轻量级容器: Spring在内存中申请了一块内存空间,用来存储其它对象.

1.2 知识铺垫

1.2.1 编辑Dog类

public class Dog {

    public void hello(){
        System.out.println("你好,我是小狗汪汪汪");
    }
}

1.2.2 编辑Cat类

public class Cat {

    public void hello(){
        System.out.println("你好,我是小猫喵喵喵");
    }
}

1.2.3 编辑测试类

package com.jt.demo1;

public class User {
    //说明: 当前类中 Dog对象与User对象绑定.耦合性高
    //如果需要切换Cat对象.则需要手动修改代码.
    //所以得出结论,如果自己实例化对象,则不能实现很好的解耦.
    private static Dog dog = new Dog();
    //private static Cat cat = new Cat();

    public static void main(String[] args) {
        dog.hello();
    }
}

1.2.4 上述代码的总结

1. 该User类与属性紧紧的绑定在一起. 耦合性高
2. 类中的方法与属性的名称绑定在一起. 耦合性高.

1.3 面向接口编程

1.3.1 面向接口编程说明

说明: 将子类中的方法 进行高级的抽取,抽取到接口中. 这时该接口用来定义行为规范准则.
面向接口编程优势: 解决了属性与方法名的耦合.以后几乎可以不修改属性名

1.3.2 代码结构

1. 定义Pet 接口
   
   2.定义Dog类
   
   3.定义Cat类
   
   4.定义测试类
   

1.4 Spring-IOC规则

1.4.1 面向接口编程弊端

说明: 虽然面向接口编程可以在一定程度上解决代码耦合性的问题.但是根源问题没有解决.
当前的User类与Cat等对象 紧紧的耦合在一起.如果后期维护,则必然要修改源码.

1.4.2 IOC调用原理图

Ioc全称Inversion of Control，即“控制反转”，这是一种设计思想。对象创建的权利由Spring框架完成.由容器管理对象的生命周期,需要的时候进行依赖注入(DI)即可.

1.5 Spring-IOC 入门案例

1.5.1 准备Dog类

package com.jt.demo2;

public class Dog {

    public void hello(){
        System.out.println("小狗 交给Spring容器管理");
    }
}

1.5.2 准备spring的配置文件

说明: spring早期都使用配置文件的方式来管理对象.但是随着软件的升级当下注解的方式已经成为主流. 所以先完成xml配置文件的方式,之后完成注解的方式.
内容说明: 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.xsd">

    <!--将Dog对象交给Spring容器管理
        1.属性id是bean的唯一标识符. 一般类名首字母小写
        2.属性class 表示被管理的类
    -->
    <bean id="dog" class="com.jt.demo2.Dog"></bean>
    <!--<bean id="cat" class="com.jt.demo2.Cat"></bean>-->

</beans>

1.5.3 准备SpringGetDog类

package com.jt.demo2;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class SpringGetDog {

    //该类表示从spring容器中,动态获取Dog对象
    public static void main(String[] args) {
        //1.指定spring配置文件路径
        String resource = "spring.xml";
        //2.启动spring容器
        ApplicationContext context =
                new ClassPathXmlApplicationContext(resource);
        //3.从容器中获取对象  必须强制类型转化
        Dog dog1 = (Dog) context.getBean("dog");
        Dog dog2 = context.getBean(Dog.class);
        System.out.println(dog1);//输出的是地址
        System.out.println(dog2);
        //4.对象调用方法
        dog1.hello();
    }
}

1.5.4 核心问题-spring如何创建对象

说明: 默认条件下,Spring容器启动时,就会创建对象,如果创建对象的过程中,出现问题.则容器启动失败.

1. 为Dog类添加构造方法
   
2. 反射代码

/**
     * Spring实例化对象的核心原理-反射机制
     * 注意事项: 反射代码 必然会调用对象的无参构造方法.
     */
    public static void getDog(){
        try {
            Dog dog = (Dog) Class.forName("com.jt.demo2.Dog").newInstance();
            dog.hello();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }

1.5.4.1 Spring创建对象的步骤

1. 定义spring的配置文件的地址.
2. Spring容器启动时加载指定的配置文件.
3. 当Spring扫描到bean标签时.加载属性id和class
4. 根据反射机制 根据class的路径反射.实例化对象.
5. Spring在内部维护了一个大型的Map<k,v>集合(容器),bean中的Id充当Map中的key. 实例化的对象充当Map中的value. 形式: Map<Id,实例化对象> 到此为止 spring容器启动成功
   6.从spring容器中通过Id或者class类型 获取对象.
   7.根据对象调用业务方法.

1.6 Spring-IOC 注解开发

1.6.1 关于注解开发说明

传统Spring框架采用xml配置文件的方式进行维护.但是随着springboot框架的崛起,注解开发渐渐的成为主流.所以将来以注解开发为准.

组成部分:
1. 实体类: Spring容器管理的类(对象)
2. 配置类: 相当于早期的xml配置文件
3. 测试代码: 利用注解的方式启动spring容器

1.6.2 编辑Cat类

package com.jt.demo3;

public class Cat {

    public Cat(){
        System.out.println("我是demo3的无参构造");
    }

    public void hello(){
        System.out.println("小花猫 喵喵喵");
    }
}

1.6.3 编辑配置类

package com.jt.demo3;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
@ComponentScan("com.jt.demo3")
                        //根据指定的包路径扫描注解,扫描当前包及其子孙包
@Configuration          //标识当前类是配置类 其实就是配置文件
public class SpringCatConfig {
    /**
     * 方法要求:
     *  1.必须为公有的
     *  2.必须添加返回值,返回值的对象,就是容器管理的对象
     *  3.方法的名称就是bean的Id
     *  4.方法必须使用@Bean注解标识
     */
    @Bean
    public Cat cat(){
        return new Cat();
    }
}

1.6.4 编辑测试类

package com.jt.demo3;

import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class SpringAnno {

    public static void main(String[] args) {
        //利用注解启动spring容器
        ApplicationContext context =
                new AnnotationConfigApplicationContext
                        (SpringCatConfig.class);
        //根据类型获取对象
        Cat cat = context.getBean(Cat.class);
        cat.hello();
    }
}

1.7 Spring中的单例-多例模式

1.7.1 概念说明

单例模式: 内存中的对象就一份.
多例模式: 内存中的对象有多份.
概念说明: Spring中的对象默认是单例的.

1.7.2 关于注解@Scope

package com.jt.demo3;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Scope;

@ComponentScan("com.jt.demo3")
                        //根据指定的包路径扫描注解,扫描当前包及其子孙包
@Configuration          //标识当前类是配置类 其实就是配置文件
public class SpringCatConfig {
    /**
     * 注解管理对象--自定义对象:
     *  1.方法必须为公有的
     *  2.必须添加返回值,返回值的对象,就是容器管理的对象
     *  3.方法的名称就是bean的Id
     *  4.方法必须使用@Bean注解标识,spring才会执行该方法,标识该对象交给Spring容器管理,
     */
    @Bean
    @Scope("prototype") //表示多例对象
    //@Scope("singleton") //表示单例对象
    public Cat cat(){
        return new Cat();
    }
}

1.8 Spring中懒加载策略

1.8.1 关于懒加载说明

默认条件下,Spring容器启动,则会创建对象.(类比:饿汉式),如果开启了懒加载.则用户什么时候使用.则对象什么时候创建(类比:懒汉式).

注解: @Lazy

 	@Bean
    @Scope("prototype") //表示多例对象
    //@Lazy                 //开启懒加载
    //@Scope("singleton") //表示单例对象
    public Cat cat(){
        return new Cat();
    }

关于多例模式和懒加载说明:
@Lazy 只能控制单例模式, 多例模式都是懒加载.

1.9 Spring生命周期

阶段划分: 对象创建/初始化/业务调用/对象销毁

1.9.1 创建Snake对象

package com.jt.demo3;

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;

public class Snake {

    //1.无参构造方法
    public Snake(){
        System.out.println("蛇蛋诞生!!!");
    }

    //2.初始化方法
    @PostConstruct
    public void init(){
        System.out.println("蛇破壳了,四处溜达");
    }

    //3.业务方法
    public void eat(){
        System.out.println("蛇四处觅食!!!");
    }

    //4.销毁方法
    @PreDestroy
    public void destroy(){
        System.out.println("打蛇七寸,一命呜呼!!!");
    }
}

1.9.2 将Snake交给Spring容器管理

 @Bean
    public Snake snake(){

        return new Snake();
    }

1.9.3 生命周期方法测试

 /**
     * 测试Bean的生命周期
     * 接口中没有提供close的方法,需要使用实现类进行操作.
     */
    public static void main(String[] args) {
        AnnotationConfigApplicationContext context =
                new AnnotationConfigApplicationContext(SpringCatConfig.class);
        Snake snake = context.getBean(Snake.class);
        snake.eat();
        //关闭容器即可
        context.close();
    }

1.10 注解总结

1. @Configuration 标识当前类是配置类
2. @ComponentScan 包扫描注解 扫描注解
3. @Bean 标识该方法的返回值交给Spring容器管理
4. @Scope 控制多例和单例
5. @Lazy 懒加载
6. @PostConstruct 初始化方法
7. @PreDestroy 销毁方法