1. Spring框架讲解

1.1 单例和多例

1.1.1 关于单例和多例说明

1. 单例： 在内存中只有一份（即使不创建，系统默认单例）
2. 多例： 在内存中可能有多份

1.1.2 创建项目springdemo5_base 

参考springdemo3-anno创建

 1.1.3 编辑User类

package com.jt.demo;

import org.springframework.stereotype.Component;

public class User {
    public User(){
        System.out.println("我是无参构造,创建对象");
    }

    public void say(){
        System.out.println("测试对象是单例还是多例");
    }
}

1.1.4 关于单例多例的测试

规则1：Spring默认管理的对象都是单例的。
规则2: 通过@Scope注解,控制对象单例/多例

package com.jt.config;

import com.jt.demo.User;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Scope;

@Configuration  //标识这是配置类
@ComponentScan("com.jt")
public class SpringConfig {

    @Bean
    @Scope("singleton")     //默认值 单例模式
    //@Scope("prototype")   //      多例模式
    public User user(){
        return new User();
    }
}

 1.1.5 编辑测试类

package com.jt;

import com.jt.config.SpringConfig;
import com.jt.demo.User;
import org.junit.jupiter.api.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestSpring {


    @Test
    public void testDemo1(){
        ApplicationContext context =
                new AnnotationConfigApplicationContext(SpringConfig.class);
        User user1 = context.getBean(User.class);
        User user2 = context.getBean(User.class);
        user1.say();
        System.out.println(user1 == user2);//true
    }
}

1.2 懒加载机制 

1.2.1 懒加载说明

说明: 如果Spring容器创建,对象立即创建则该加载方式为 “立即加载”, 容器启动创建
如果Spring容器创建,对象在被使用的时候才创建, 则称为"懒加载" 用时才创建

注解: @Lazy 添加表示改为懒加载
测试说明: 主要测试对象中的无参构造什么时候执行!!!

 1.2.2 懒加载用法

package com.jt.config;

import com.jt.demo.User;
import org.springframework.context.annotation.*;

@Configuration  //标识这是配置类
@ComponentScan("com.jt")
public class SpringConfig {

    @Bean
    //@Scope("singleton")    //默认值 单例模式
    //@Scope("prototype")    //  多例模式
    @Lazy                    //懒加载
    public User user(){
        return new User();
    }
}

1.2.3 多例与懒加载的关系

说明: 只要对象是多例模式,则都是懒加载!, 在单例模式中控制懒加载才有效.
规则说明:
lazy true lazy false
单例模式: 有效 懒加载 有效 立即加载
多例模式: 无效 懒加载 无效 懒加载

 1.2.4 关于lazy 使用场景的说明

场景1: 服务器启动时,如果加载太多的资源,则必然导致服务器启动慢, 适当的将不重要的资源设置为懒加载.
场景2: 有时用户会需要一些特殊的"链接",而这些链接的创建需要很长的时间.可以使用懒加载.

1.3 Spring对象生命周期管理 

1.3.1 关于对象生命周期说明

说明: 一个对象从创建到消亡,可以划分为四个阶段. 如果需要对程序进行干预.则可以通过周期方法进行干预. (回调函数/钩子函数/接口回调)
图解说明生命周期函数的作用: 主要作用可以在各个时期对对象进行干预

 1.3.2 生命周期函方法的使用

package com.jt.demo;

import org.springframework.stereotype.Component;

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

@Component  //将对象交给Spring容器管理 key=person value:反射对象
public class Person {

    public Person(){
        System.out.println("张三出生了,资质拉满");
    }

    @PostConstruct  //在对象创建之后立即调用
    public void init(){
        System.out.println("张三称为少年奇才");
    }

    //业务方法
    public void doWork(){
        System.out.println("迎娶美人鱼!!!");
    }

    @PreDestroy //对象消亡时 进行调用
    public void destory(){
        System.out.println("销毁:全世界哀悼");
    }
}

1.3.3 测试案例 

@Test
    public void testDemo3Init(){
        //容器启动对象创建
        AnnotationConfigApplicationContext context =
                new AnnotationConfigApplicationContext(SpringConfig.class);
        Person person = context.getBean(Person.class);
        person.doWork();
        //将容器关闭
        context.close();
    }

1.3.4 使用注解 

1. @PostConstruct //在对象创建之后立即调用

2. @PreDestroy //对象消亡时 进行调用

1.2 依赖注入（Dependency Injection，简称DI） 

1.2.1 创建结构 

1. 准备User类
2. 准备Dog类
3. 准备Cat类
   说明: Dog/Cat向User类进行对象的注入功能.

 1.2.2 @Autowired注解

说明: 在对象中如果需要使用属性注入.一般使用@Autowired注解.
功能: 可以将Spring容器中的对象,自动注入到属性中.
注入方式:
1. 默认按照类型注入. 如果注入的属性是接口,则自动注入实现类
2. 按照名称注入(key). 一般不用

重要前提: 如果需要依赖注入.则对象必须交给Spring容器管理.

 1.2.3 编辑Pet接口

public interface Pet {
    void hello();
}

1.2.4 编辑Cat类 

package com.jt.demo;

import org.springframework.stereotype.Component;

@Component //将对象交给spring容器管理 key:cat value:反射Cat对象
public class Cat implements Pet{

    @Override
    public void hello() {
        System.out.println("我是喵喵喵");
    }
}

1.2.5 编辑User类

package com.jt.demo;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component  //将user交给Spring容器管理
public class User {

    //效果: 将当前接口的实现类自动注入
    @Autowired
    private Pet pet;

    public void say(){
        //调用宠物的方法
        pet.hello();
    }
}

1.2.6 编辑配置类 

package com.jt.config;

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

@Configuration            //标识我是配置类
@ComponentScan("com.jt")  //必须添加包路径
public class SpringConfig {

}

1.2.7 编辑测试类

package com.jt;

import com.jt.config.SpringConfig;
import com.jt.demo.User;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

class TestSpring {

    @Test
    public void testDemo1(){
        ApplicationContext context =
                new AnnotationConfigApplicationContext(SpringConfig.class);
        User user = context.getBean(User.class);
        user.say();
    }

}

1.3 接口多实现的情况说明 

1.3.1 代码说明

1.猫类 

 2.狗类 

1.3.2 报错说明

说明: 一个接口应该只有一个实现类,否则spring程序无法选择. 

 1.3.3 解决方案

package com.jt.demo;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Component;

@Component  //将user交给Spring容器管理
public class User {

    //效果: 将当前接口的实现类自动注入
    @Autowired
    @Qualifier("cat") //该注解不能单独使用,必须配合Autowired使用,根据key进行注入
    private Pet pet;  //2选1

    public void say(){
        //调用宠物的方法
        pet.hello();
    }
}

 1.3.4 @Resource注解说明

1.4 MVC 设计思想 

1.4.1 MVC思想说明

经典MVC模式中，M是指业务模型，V是指用户界面，C则是控制器，使用MVC的目的是将M和V的实现代码分离，从而使同一个程序可以使用不同的表现形式。其中，View的定义比较清晰，就是用户界面。

M: model 业务模型
V: view 用户界面
C: control 控制层

历史说明:
JSP动态页面 html代码 + java代码 写到一起 xxx.jsp
不方便后期维护. 页面和业务执行紧紧的绑定在一起耦合性高.

 小结:
1. MVC是一种设计思想,编码中降低代码的耦合性.
2. 前端专注于开发页面 view
3. 后端专注于开发后端 model
4. 2者通过control 进行控制

1.4.2 层级代码结构

说明: MVC设计思想,实现了前端和后端的松耦合.但是根据实际的开发情况,很多的业务逻辑比较复杂.如果后端将所有的代码都写到同一个java类中.这样的代码结构很臃肿. 为了很好的实现MVC设计思想.所以后端代码也应该分层.

 分层说明:
1. 控制层 Controller 与前端页面交互的. @Controller
2. 业务层 Service 编辑业务逻辑. @Service
3. 持久层 Mapper 实现数据库的相关操作 暂时:@Repository
MVC > 三层代码结构!!!

1.5 三层代码结构 

1.5.1 编辑Mapper层