80.【Spring5】（一）-阿里云开发者社区

(一)、Spring 简介

https://docs.spring.io/spring-framework/docs/current/reference/html/core.html#spring-core

Spring框架是由于软件开发的复杂性而创建的。Spring使用的是基本的JavaBean来完成以前只可能由EJB完成的事情。然而，Spring的用途不仅仅限于服务器端的开发。从简单性、可测试性和松耦合性角度而言，绝大部分Java应用都可以从Spring中受益。

1.历史:

2022年: Spring 雏形形成。

2004年，Spring 一代正式发布。

2.Spring 目的

是现有的技术更加简单，本身是一个大杂烩，整合了现有的技术框架

SSH : Struct2 + Spring + Hibernate

SSM: SpringMvc+ Spring + Mybatis

3.Spring 引入

<!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>5.2.0</version>
</dependency>

4.优点

Spring 是一个免费开源的网站
Spring 是一个轻量级的，非入侵式的框架
控制反转(IOC) ，面向切面编程(AOP)
支持事务的处理，对框架整合的支持
Spring 就是一个轻量级的控制反转(IOC)和切面编程(AOP)的框架

5.Spring 七大模块组成:

6.扩展（约定大于配置）

SpringBoot 一个快速开发的脚手架,可以快速开发一个微服务
SpringCloud 是基于SpringBoot实现的
学习SpringBoot 的前提是完全掌握 SpringMVC Spring

(二)、IOC理论推导(Inversion of Contro)

1.以前的三层分级

Dao ：用于处理数据库的语句信息
Dao层接口

package Com.Jsxs.Dao;
public interface UserDao {
    void getUser();
}

Dao层实现类01

package Com.Jsxs.Dao;
public class UserDaoImpl implements UserDao{
    @Override
    public void getUser() {
        System.out.println("用户信息，被查询");
    }
}

Dao层实现类02

package Com.Jsxs.Dao;
public class MysqlUserDaoImpl implements UserDao{
    @Override
    public void getUser() {
        System.out.println("mysql 调用用户数据");
    }
}

Servic ：e 用于连接数据库，调用Dao
业务接口层

package Com.Jsxs.Service;
public interface UserService {
    void getUser();
}

死型业务接口实现类

package Com.Jsxs.Service;
import Com.Jsxs.Dao.UserDao;
import Com.Jsxs.Dao.UserDaoImpl;
public class UserServiceImpl implements UserService{
    private UserDao userDao;
//   程序写死的状态
  public UserServiceImpl() {
       userDao=new UserDaoImpl();
  }
    @Override
    public void getUser() {
        userDao.getUser();
    }
}

活性业务层实现类（现在）

package Com.Jsxs.Service;
import Com.Jsxs.Dao.UserDao;
import Com.Jsxs.Dao.UserDaoImpl;
public class UserServiceImpl implements UserService{
    private UserDao userDao;
    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }
    @Override
    public void getUser() {
        userDao.getUser();
    }
}

Servlet ：用于调用Service 层

2.现在对三层架构的更新

我们之前的业务中，用户的需求可能会影响我们原来的代码，我们需要根据用户的需求去修改代码。如果代码的数据量非常庞大，那么修改代码的成本的价值非常昂贵！！

利用 set 实现数据的动态注入
    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

程序的控制权由(ServiceImpl层) 转向了 (Servlet层)；程序员----》用户自己

这种思想，从本质上解决了问题，我们程序员不用再去管理对象的创建了，系统的耦合性（关联）大大降低，可以更加的专注于业务的实现。

这一操作实现了IOC控制权的反转

3.什么是IOC

ioc是由spring来负责控制对象的生命周期和对象间的关系。ioc容器（Inversion of Control，控制反转）是spring的核心，贯穿始终。Ioc意味着将你设计好的对象交给容器控制，主要控制了外部资源获取。

控制反转是一种通过描述(XML 或注解) 并通过第三方去生产或获取特定对象的方式，在Spring 中控制反转的是IOC容器，其实现方法是依赖注入(Dependency injection , DI)

(三)、HelloSpring

1.怎么使用Spring?

(1). 导入Spring 的版本jar包

<!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>6.0.2</version>
</dependency>

(2).导入资源文件包(XMI)

(3).编写配置文件

使用Spring 来创建对象，在Spring 这些都称为Bean
    bean: 就是对象; ===> new Hello();
    id: 就是变量名;
    class :全限定名
    property: 相当于给对象中的属性赋值
    name : 键，给谁赋值?
    value : 值，赋值什么
    contex.getBean(" id ")

–

<?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">
<!--    使用Spring 来创建对象，在Spring 这些都称为Bean
        bean: 就是对象; ===> new Hello();
        id: 就是变量名;
        class :全限定名
        property: 相当于给对象中的属性赋值
        name : 键，给谁赋值?
        value : 值，赋值什么
-->
    <bean id="hello" class="Com.Jsxs.pojo.Hello">
<!--        name 就是 类中的变量名， value : 随便起-->
        <property name="str" value="Spring"/>
    </bean>
</beans>

(4).第一个Spring

实体类

package Com.Jsxs.pojo;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
@AllArgsConstructor
@Data
@NoArgsConstructor
public class Hello {
    private String str;
}

配置文件

<?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">
<!--    使用Spring 来创建对象，在Spring 这些都称为Bean
        bean: 就是对象; ===> new Hello();
        id: 就是变量名;
        class :全限定名
        property: 相当于给对象中的属性赋值
        name : 键，给谁赋值?
        value : 值，赋值什么
-->
    <bean id="hello" class="Com.Jsxs.pojo.Hello">
<!--        name 就是 类中的变量名， value : 随便起-->
        <property name="str" value="Spring"/>
    </bean>
</beans>

测试

import Com.Jsxs.pojo.Hello;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.context.ApplicationContext;
public class MyTest {
    public static void main(String[] args) {
//        绑定 beans.xml 配置文件 ,并获取Spring上下文的对象
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
//        我们的对象现在都在Spring 中 进行管理了，我们要使，直接进去取出来就可以了
        Hello hello =(Hello) context.getBean("hello");
        System.out.println(hello.toString());
    }
}

2.雏形项目

Dao层接口

package Com.Jsxs.Dao;
public interface UserDao {
    void getUser();
}

Dao层实现类1

package Com.Jsxs.Dao;
public class MysqlUserDaoImpl implements UserDao{
    @Override
    public void getUser() {
        System.out.println("mysql 调用用户数据");
    }
}

Dao层实现类2

package Com.Jsxs.Dao;
public class UserDaoImpl implements UserDao{
    @Override
    public void getUser() {
        System.out.println("用户信息，被查询");
    }
}

Service接口

package Com.Jsxs.Service;
public interface UserService {
    void getUser();
}

Service接口的实现类（一定要设置set 方法）

package Com.Jsxs.Service;
import Com.Jsxs.Dao.UserDao;
import Com.Jsxs.Dao.UserDaoImpl;
public class UserServiceImpl implements UserService{
    private UserDao userDao;
    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }
    @Override
    public void getUser() {
        userDao.getUser();
    }
}

Spring配置文件

ref : 引用Spring 中已经创建好的对象
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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    <bean id="mysqlDaI" class="Com.Jsxs.Dao.MysqlUserDaoImpl"/>
    <bean id="userDaI" class="Com.Jsxs.Dao.UserDaoImpl"/>
    <bean id="userSev" class="Com.Jsxs.Service.UserServiceImpl">
<!--
        ref : 引用Spring 中已经创建好的对象
        value : 具体的值  ，赋值；基本数据类型。
-->
        <property name="userDao" ref="userDaI"/>
    </bean>
</beans>

测试

ApplicationContext context = new ClassPathXmlApplicationContext("resource 目录下的资源");

import Com.Jsxs.Dao.MysqlUserDaoImpl;
import Com.Jsxs.Service.UserService;
import Com.Jsxs.Service.UserServiceImpl;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class test1 {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        UserService userSev = (UserService) context.getBean("userSev");
        userSev.getUser();
    }
}

3.总结:

有了Spring ,我们就彻底不用在程序中去改动了，要实现不同的操作只需要在XML配置文件中进行修改，所谓的IOC,就是:对象由Spring进行创建，管理，配置。
依赖注入: 就是利用set方法进行注入
IOC: 是一种编程思想，由主动的编程变成了被动的编程
反转: 程序本身不再创建对象，转变成被动的接受对象
控制: 谁来控制对象的创建。
一定要存在 set 方法，Spring主要依赖于set方法进行DI注入。
如果使用Spring6 ,那么JDK的版本一定要高一点
如果输出中文乱码，电脑右下角输出为 GBK,不要 UTF-8

(四)、IOC对象的创建方式

1.使用无参构造函数创建对象（不存在有参）

(1).反列(没有设置无参构造函数)

package Com.Jsxs.pojo;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
@Data
public class User {
    private String name;
    public User(String name){
        System.out.println("有参构造函数!!");
    }
    public void show(){
        System.out.println("name="+name);
    }
}

(2).正列 (有设置无参构造函数，没有设置有参构造)

实体类

package Com.Jsxs.pojo;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
@Data
public class User {
    private String name;
    public User(){
        System.out.println("无参构造函数!!");
    }
    public void show(){
        System.out.println("name="+name);
    }
}

配置

<?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">
        <bean id="user" class="Com.Jsxs.pojo.User">
            <property name="name" value="吉士先生"/>
        </bean>
</beans>

测试

import Com.Jsxs.pojo.User;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class MyTest {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        User user = (User) context.getBean("user");
        user.show();
    }
}

80.【Spring5】（一）