狂神说spring

狂神说spring

1.spring

1.1 简介

• spring:春天

• 2002年,首次推出了spring框架的雏形: interface21框架

• spring框架以inferface21框架为基础,经过重新设计,并不断丰富其内涵,于2004年3月24日发布了1.0正式版

• spring理念:使现有的技术更加容易使用,本身是一个大杂烩,整合了现有的技术框架

• ssh:struct2+spring+hibernate

• SSM:springmvc+spring+mybatis

spring官网

GitHub:https://github.com/spring-projects/spring-framework

spring maven依赖

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>5.2.0.RELEASE</version>
</dependency>

<!-- 整合mybatis所需要的包 -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-jdbc</artifactId>
    <version>5.2.0.RELEASE</version>
</dependency>

1.2 优点

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

spirng就是一个轻量级的控制反转(IOC)和面向切面编程的框架(AOP)

1.3 组成

七大模块

1.4 拓展

现在的java开发,说白了就是基于java开发

• springboot
  • 一个快速开发的框架
  • 基于springboot可以快速开发单个微服务
  • 约定大于配置
• springcloud
  • springcloud是基于springboot实现的
• springsecurity
  • 安全控制

现在大多数公司都在使用springboot进行快速开发,学习springboot的前提是完全掌握spring和springmvc!

弊端:发展了太久之后,违背了原来的理念!配置十分繁琐.

2.IOC理论

• 原来的过程
  • 接口
  • 实现类
  • 业务接口
  • 业务实现类

private UserDao userDao = new UserDaoImpl();

UserDao每多一个功能实现类,我们都需要调整底层code

在之前的业务中,用户的需求可能会影响我们原来的代码,我们需要根据用户的需求改源代码!如果程序代码量很大,成本会十分昂贵!

我们使用一个set接口实现(已经发生了革命性的变化)

public void setUserDao(UserDao userdao) {
   
    this.userDao = userdao;
}

• 之前程序是主动创建对象!控制权在程序员手上!
• 使用了set注入后,程序不再具有主动性,而是变成了被动的接收对象.
• 这就是控制反转

这种思想从本质上解决了问题,程序员不用再去管理对象的创建了.系统的耦合性大大降低了,可以更加专注的在业务的实现上.这是IOC的原型

之前和使用set注入之后

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-iSJ3R8in-1632825335663)(狂神说spring.assets/image-20210918153443536.png)]

2.1 IOC本质

IOC是一种设计思想,DI是IOC的一种实现方式

所谓控制反转,就是**获得依赖对象的方式反转了**

IOC是spring框架的核心内容

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

3.HelloSpring

3.1 测试样例

• pojo

package pojo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Hello {
   
    private String name;
}

• beans.xml

<?xml version="1.0" encoding="UTF8"?>
<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
        https://www.springframework.org/schema/beans/spring-beans.xsd">

    <!--
        使用spirng来创建,在spring中这些都成为bean

        类型    变量名   =  new  类型();
        Hello   hello  =  new  Hello();

        id = 变量名
        class = new的对象
        property  相当于给对象中的属性设置一个值
			赋值的两种参数
			value:一般类型和string类型
			ref:引用类型
    -->
    <bean id="hello" class="pojo.Hello">
        <property name="name" value="spring"></property>
    </bean>

</beans>

• test

@Test
public void test01(){
   
    /*
        * 获取spring的上下文对象
        */
    ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
    /*
        * 我们的对象现在都在spring中管理了,我们要使用,直接从里面获取就可以了
        * */
    Hello hello = (Hello) context.getBean("hello");
    System.out.println(hello);
}

问题

• hello对象是谁创建的?

spring

• hello对象的属性是怎么设置的

spring容器设置的

这个过程就叫控制反转

• 控制:传统应用程序的对象是由程序本身创建的,使用spring之后,对象是spring创建的
• 反转:程序本身不创建对象,变成了被动接受对象
• 依赖注入:就是利用set方法来进行注入的

IOC是一种编程思想,由主动的编程变成被动的接收.

所谓IOC:对象由spring来创建,管理,装配.

4.IOC创建对象的方式

• 使用无参构造方法创建对象,默认!

• 假设我们使用有参来构造

  • 下标赋值

  <bean class="pojo.User" id="User">
      <!--<property name="name" value="kuquan"></property>-->
      <!--有参构造,下标赋值-->
      <constructor-arg index="0" value="kuquan"></constructor-arg>
  </bean>
  

  • 类型赋值

  <bean class="pojo.User" id="User">
      <!--有参构造,通过类型创建,不推荐-->
      <constructor-arg type="java.lang.String" value="kuquan"></constructor-arg>
  </bean>
  

  • 直接通过参数名来设置

  <bean class="pojo.User" id="User">
      <!--有参构造,参数名获取-->
      <constructor-arg name="name" value="kuquan"></constructor-arg>
  </bean>
  

总结:在配置文件加载的时候,容器中管理的对象就已经实例化了.

5.spring配置

5.1 别名

<bean class="pojo.User" id="User">
    <constructor-arg name="name" value="kuquan"></constructor-arg>
</bean>

<alias name="User" alias="test"></alias>

通过bean本来的名字和别名都能获取到对象

<alias name="User" alias="test"></alias>

alias中的name取注册过的bean的id

5.2 Bean配置

<bean class="pojo.User" id="User" name="user">
    <constructor-arg name="name" value="kuquan"></constructor-arg>
</bean>

• id:bean的唯一标识符,也就是相当于对象名
• class:bean对象所对应的全限定名
• name:起别名,而且同时取多个别名(多个别名时可以用 逗号or空格or分号 分割)

5.3 import

一般用于团队开发使用,它可以将多个配置文件,导入合并为一个

假设现在项目中由多人开发,这三个人负责不同的类开发,不同的类需要注册在不同的bean中,我们可以用import将所有人的beans.xml合并为一个总的!

<import resource="beans1.xml"></import>
<import resource="beans2.xml"></import>
<import resource="beans3.xml"></import>

使用的时候直接使用总的配置文件就可以了

6.依赖注入

6.1 构造器注入

前面说过了

<bean class="pojo.User" id="User">
    <!--有参构造,参数名获取-->
    <constructor-arg name="name" value="kuquan"></constructor-arg>
</bean>

6.2 Set方式注入[重点]

• 依赖注入:Set注入!
  • 依赖:bean对象的创建依赖于容器!
  • 注入:bean对象种的所有属性,由容器来注入!

[环境搭建]

• 复杂类型

package pojo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Address {
   
    private String address;
}

• 真实测试对象

package pojo;

import com.sun.xml.internal.ws.api.ha.StickyFeature;
import javafx.scene.effect.SepiaTone;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.Set;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Student {
   
    private String name;
    private Address address;
    private String[] books;
    private List<String> hobbys;
    private Map<String, String> card;
    private Set<String> games;
    private Properties info;
    private String wife;
}

• beans.xml

<?xml version="1.0" encoding="UTF8"?>
<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
        https://www.springframework.org/schema/beans/spring-beans.xsd">

</beans>

• 完善注入信息

<?xml vers