day03笔记

Spring框架讲解

单例和多例

单例：对象在内存中只有一份
多例：对象在内存中可能有多份

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

@Scope("singleton")        单例模式   默认就是单例
@Scope("prototype")        多例模式

懒加载机制

懒加载说明

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

注解: @Lazy 添加表示改为懒加载

多例与懒加载的关系

说明：只有在单例模式中添加懒加载才有效，因为多例模式都是懒加载

关于lazy使用场景的说明

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

Spring对象生命周期管理

关于对象生命周期说明

说明：一个对象从创建到消亡,可以划分为四个阶段. 如果需要对程序进行干预.则可以通过周期方法进行干预. (回调函数/钩子函数/接口回调)

注解：@PostConstruct //在对象创建之后立即调用
           @PreDestroy //对象消亡时 进行调用

生命周期函数方法的使用

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("销毁:全世界哀悼");
    }
}

测试案例

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

依赖注入

@Autowired注解

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

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

如果是一个接口有两个实现类，那么这个时候必须按照名称注入，因为系统不会做“选择题”

@Qualifier("xxx")

该注解不能单独使用必须配合Autowired使用，根据key进行注入

@Resource注解说明

@Resource(name = "xxx")注解        等同于        @autowired注解 + @Qualifier("xxx")

但是一般不用，了解即可，因为他不是spring框架自身的注解，万一出现不兼容就得不偿失了！！！

mvc设计思想

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 进行控制

层级代码结构

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

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

三层代码结构

编辑Mapper层

编辑mapper接口

package com.jt.mapper;
//面向接口开发
public interface UserMapper {

    void  addUser();
}

编辑MapperImpl

package com.jt.mapper;

import org.springframework.stereotype.Repository;

@Repository //为了让程序员开发有层级的概念
public class UserMapperImpl implements UserMapper{

    @Override
    public void addUser() {
        System.out.println("新增用户AAA");
    }
}

编辑Service层

编辑UserService接口

package com.jt.service;

public interface UserService {

    void addUser();
}

编辑UserServiceImpl

package com.jt.service;

import com.jt.mapper.UserMapper;
import com.jt.mapper.UserMapperImpl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class UserServiceImpl implements UserService{

    @Autowired
    private UserMapper userMapper; //默认按照类型注入

    @Override
    public void addUser() {
        userMapper.addUser();
    }
}

编辑Controller层

package com.jt.controller;

import com.jt.service.UserService;
import com.jt.service.UserServiceImpl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;

//controller层只有类 不用写接口
@Controller
public class UserController {

    @Autowired
    private UserService userService;

    public void addUser(){
        userService.addUser();
    }
}

编辑配置类

package com.jt.config;

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

@Configuration
@ComponentScan("com.jt")
public class SpringConfig {
}

编辑测试类

package com.jt;

import com.jt.config.SpringConfig;
import com.jt.controller.UserController;
import org.junit.jupiter.api.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class TestSpring {

    @Test
    public void testDemo1(){
        ApplicationContext context =
                new AnnotationConfigApplicationContext(SpringConfig.class);
        UserController userController = context.getBean(UserController.class);
        userController.addUser();
    }
}

谈一下你对IOC/DI的看法(开放)

历史: 传统代码其中的属性对象一般都是通过new关键字手动创建,这样的代码耦合性高,不方便扩展
功能:
1. IOC: 由Spring容器管理对象的生命周期.
2. 使得对象与对象之间的耦合性降低.
3. DI是依赖注入. 只有被spring容器管理的对象才可以被依赖注入. 默认的条件下采用类型注入.如果有特殊需求也可以采用名称注入(@Qualifier(“cat”))
4. Spring中 IOC和DI相互配合,可以极大程度上降低耦合性.

意识:
Spring由于采用了IOC/DI的设计方式,可以整合其它的第三方框架.使得程序的调用"浑然一体"

@Value注解说明

注解赋值

说明: @Value注解 可以直接为基本类型赋值和String类型，也可以为集合赋值，但基本不用
问题: 如果像图中赋值,则耦合性依然很高,不通用. 需要优化!!!

编辑user.properties

说明: 对象中的属性一般都是业务数据,如果需要为业务数据赋值,则一般采用properties文件 更加灵活.
位置: 在resources目录下

 字符集编码说明:

 配置文件内容:

#1.注意事项:  key=value  等号连接  2.中间不要添加多余的空格
#2.说明: windows系统中有环境变量username=系统用户名称,以后写业务数据时,最好绕开关键字username
#3.编码规则: 程序读取properties文件时,默认采用ISO-8859-1编码
user.username=葫芦娃

@value为属性赋值

package com.jt.mapper;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.PropertySource;
import org.springframework.stereotype.Repository;

@Repository //为了让程序员开发有层级的概念
@PropertySource(value="classpath:/user.properties",encoding = "UTF-8")
//classpath:/  代表resources的根目录
public class UserMapperImpl implements UserMapper{
    //耦合性!!!!
    // 表达式: 固定写法  springel表达式 取值方式 缩写spel表达式
    // 规则:通过key动态获取spring容器中的value
    @Value("${user.username}")
    private String username;

    @Override
    public void addUser() {
        System.out.println("新增用户:"+username);
    }
}