Spring

1、Spring

1.1、简介

  • spring :春天———>给软件行业带来了春天!

  • 2002,首次退出Springkuang框架雏形,interface21框架!

  • spring 框架即以interface21框架为基础,经过重新设计,不断丰富其内涵,于2004年3月24日发布1.0版本。

  • Rod Johnson,Spring Framework创始人,Java和J2EE开发领域的专家。很难以想象,悉尼大学的音乐学博士,然而他的专业不是计算机,而是音乐学。

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

  • SSH ; Struct2 + spring + Hibernate!

  • SSM : springmvc + spring + mybatis

官网文档 Spring Framework Documentation

历史文档 Index of /spring-framework/docs

官网接口 Overview (Spring Framework 5.2.24.RELEASE API)

下载地址 http://repo.spring.io/release/org/springframework/spring

​ github github.com

											经典版本4.3.9
<!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>5.2.9.RELEASE</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-jdbc</artifactId>
    <version>5.2.9.RELEASE</version>
</dependency>

1.2、优点

  • spring是一个免费的开源的容器【框架】
  • spring是一个轻量级非入侵式的框架 不会对原来的项目产生影响
  • 控制反转(IOC),面相切面编程(AOP)
  • 支持事务处理,对框架整合的支持

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

1.3、组成

1.4、拓展

spring官网介绍:现代化的java开发!说白了就是基于spring的开发!

  • Spring Boot

    • 一个快速开发的脚手架
    • 基于SpringBoot可以快速的开发单个微服务
    • 约定大于配置!
  • Spring Cloud

    • Spring Cloud 是基于Spring Boot实现的

因为现在大多数公司都在使用Spring Boot 进行快速开发, 学习Spring Boot 的前提,需要完全掌握Spring以及SpringMVC!承上启下

弊端 : 发展太久后违背了原来的理念! 配置十分繁琐,人称 “配置地狱”

2、IOC理论推导

  1. UserDao 接口
    1.
  2. UserDaoImpl 实现类
    1.
  3. UserService 业务接口
    1.
  4. UserServiceImpl 业务实现类
    1.

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

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

private UserDao userDao;
// 利用set 进行动态实现值的注入
public void setUserDao(UserDao userDao) {
    this.userDao = userDao;
}
  • 之前,程序是主动创建对象!控制权在程序员手上
  • 使用了set注入之后,程序员不再具有主动性,而是变成了被动接受对象!

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

ioc本质

控制反转IOC (Inversion of Control) , 是一种设计思想,DI(依赖注入)是实现IOC的一种方法,也有人认为DI 只是IOC的另一种说法。没有IOC的程序中,我们使用面相对象编程,对象的创建与对象间的依赖关系完全硬编码在程序中,对象的创建由程序自己控制,控制反转后将对象的创建移交给第三方,个人认为所谓控制反转就是:获得依赖对象的方式反转了。

采用 XML 方式配置bean的时候,bean的定义信息和实现分离的,而采用注解的方式可以把两者合为一体,bean的定义信息直接以注解的形式定义在实现类中,从而达到了零配置的目的。

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

IoC是Spring框架的核心内容,使用多种方式完美的实现了IoC,可以使用XML配置,也可以使用注解,新版本的Spring也可以零配置实现IoC。

Spring容器在初始化时先读取配置文件,根据配置文件或元数据创建与组织对象存入容器中,程序使用时再从Ioc容器中取出需要的对象。

3、HelloSpring

3.1、导入jar包

注 : spring 需要导入commons-logging进行日志记录 . 我们利用maven , 他会自动下载对应的依赖项 .

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

3.2、编写代码

1、编写一个Hello实体类

public class Hello {
   private String name;

   public String getName() {
       return name;
  }
   public void setName(String name) {
       this.name = name;
  }

   public void show(){
       System.out.println("Hello,"+ name );
  }
}

2、编写我们的spring文件 , 这里我们命名为beans.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">

   <!--bean就是java对象 , 由Spring创建和管理-->
   <bean id="hello" class="com.kuang.pojo.Hello">
       <property name="name" value="Spring"/>
   </bean>
</beans>

3、我们可以去进行测试了 .

@Test
public void test(){
   //解析beans.xml文件 , 生成管理相应的Bean对象
   ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
   //getBean : 参数即为spring配置文件中bean的id .
   Hello hello = (Hello) context.getBean("hello");
   hello.show();
}

3.3、思考

  • Hello 对象是谁创建的 ? 【hello 对象是由Spring创建的
  • Hello 对象的属性是怎么设置的 ? hello 对象的属性是由Spring容器设置的

这个过程就叫控制反转 :

  • 控制 : 谁来控制对象的创建 , 传统应用程序的对象是由程序本身控制创建的 , 使用Spring后 , 对象是由Spring来创建的
  • 反转 : 程序本身不创建对象 , 而变成被动的接收对象 .

依赖注入 : 就是利用set方法来进行注入的.

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

可以通过newClassPathXmlApplicationContext去浏览一下底层源码 .

3.4、修改案例一

我们在案例一中, 新增一个Spring配置文件beans.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">

   <bean id="MysqlImpl" class="com.kuang.dao.impl.UserDaoMySqlImpl"/>
   <bean id="OracleImpl" class="com.kuang.dao.impl.UserDaoOracleImpl"/>

   <bean id="ServiceImpl" class="com.kuang.service.impl.UserServiceImpl">
       <!--注意: 这里的name并不是属性 , 而是set方法后面的那部分 , 首字母小写-->
       <!--引用另外一个bean , 不是用value 而是用 ref-->
       <property name="userDao" ref="OracleImpl"/><!--具体使用哪个接口这里可以直接配置-->
   </bean>

</beans>

测试!

@Test
public void test2(){
   ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
   UserServiceImpl serviceImpl = (UserServiceImpl) context.getBean("ServiceImpl");//这里相当于将原来的Service层也IOC了,不需要再在代码中写出调用哪个接口,只需要在配置文件中指明调用的接口即可。
   serviceImpl.getUser();
    //原来的步骤
    //UserService userService = new UserServiceImpl();
    //userService.setUserDao(new UserDaoMysqlImpl());//原先需要在代码中调用特定的方法
	//userService.getUser();
}

OK , 到了现在 , 我们彻底不用再程序中去改动了 , 要实现不同的操作 , 只需要在xml配置文件中进行修改 , 所谓的IoC,一句话搞定 : 对象由Spring 来创建 , 管理 , 装配 !

思考问题:

  • Hello 对向是谁创建的?

  • Hello 对象是由Spring 创建的

  • Hello 对象的属性是怎么设置的?

  • hello 对象的属性是spring容器设置

4、IOC 创建对象的方式

  1. 使用无参构造创建对象,默认!

  2. 假设我们要使用有参构造创建对象。

    1. 下标赋值

              <!--    下标赋值     -->
      <bean id="user" class="com.lmq.pojo.User">
          <constructor-arg index="0" value="000"/>
      </bean>
      
    2. 类型赋值

              <!--  2(不建议使用)  通过类型创建   基本类型直接用  引用类型全名   -->
      <bean id="user" class="com.lmq.pojo.User">
          <constructor-arg value="111" type="java.lang.String"/>
      </bean>
      
    3. 参数名 重点掌握

          <!--  3 直接通过参数名来设置  -->
      <bean id="user" class="com.lmq.pojo.User">
          <constructor-arg name="name" value="333"/>
      </bean>
      

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

5、Spring配置

5.1、 别名

    <!-- 别名 -->
    <alias name="user" alias="userNew"/>

5.2、 Bean的配置

<!--
    id    : nean 的唯一标识符,也就是相当于我们学的对象名
    class : bean 对象所对应的全 限定名 : 包名 + 类型
    name  : 也是别名,而且name 可以取多个别名 逗号分割等
-->
<bean id="userT" class="com.lmq.pojo.UserT" name="t,userT2">

5.3、import

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

假设,现在项目中有多个人开发 这三个人负责不同的类开发 不同的类要注册在不同的bean中

我们可以使用import将所有人的合并为一个总的

  • 张三
  • 李四
  • 王五
  • applicationContext
<?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
        https://www.springframework.org/schema/beans/spring-beans.xsd">
    <import resource="beans.xml"/>
    <import resource="beans2.xml"/>
    <import resource="beans3.xml"/>
</beans>

内容相同也会合并

6、DI 依赖注入

6.1、构造器注入

前面已经使用

6.2、set方式注入【重点】

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

【环境搭建】

  1. 复杂类型

    public class Address {
        private String address;
    
        @Override
        public String toString() {
            return "Address{" +
                    "address='" + address + '\'' +
                    '}';
        }
    
        public String getAddress() {
            return address;
        }
    
        public void setAddress(String address) {
            this.address = address;
        }
    }
    
  2. 真实测试对象

    @Data
    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 String wife;
        private Properties info;
    }
    
  3. beans.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">
        <bean id="student" class="com.lmq.pojo.Student">
            <property name="name" value="lmq"/>
        </bean>
    </beans>
    
  4. 测试类

    import com.lmq.pojo.Student;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    /**
     * @author 羡鱼
     * @version 1.0
     * @date 2023/6/23 22:00
     */
    public class MyTest {
        public static void main(String[] args) {
            ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
            Student student = (Student) context.getBean("student");
            System.out.println(student.getName());
        }
    }
    
    
  5. 完善注入信息

    <?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="address" class="com.lmq.pojo.Address">
            <property name="address" value="湖北"/>
        </bean>
    
        <bean id="student" class="com.lmq.pojo.Student">
            <!--  第一种 普通注入,value      -->
            <property name="name" value="lmq"/>
    
            <!-- 第二种 bean注入 ref -->
            <property name="address" ref="address"/>
            <!-- 第三种 数组注入 -->
            <property name="books">
                <array>
                    <value>三国演义</value>
                    <value>西游记</value>
                    <value>水浒传</value>
                    <value>红楼梦</value>
                </array>
            </property>
            <!-- 第四种 List -->
            <property name="hobbys">
                <list>
                    <value>骑单车</value>
                    <value>学习</value>
                    <value>看电视</value>
                </list>
            </property>
    
            <!-- map -->
            <property name="card">
                <map>
                    <entry key="身份证" value="1234546123456781234"/>
                    <entry key="银行卡" value="12345612347561234"/>
                    <entry key="学生卡" value="123789123789"/>
                </map>
            </property>
            <!-- set -->
            <property name="games">
                <set>
                    <value>LOL</value>
                    <value>COC</value>
                    <value>BOB</value>
                </set>
            </property>
            <!-- 空值注入 -->
            <property name="wife">
                <null/>
            </property>
            <!-- Property -->
            <property name="info">
                <props>
                    <prop key="学号">123456789</prop>
                    <prop key="url">男</prop>
                    <prop key="name">123</prop>
                    <prop key="pwd">123</prop>
                </props>
    
            </property>
    
    
        </bean>
    
    </beans>
    

6.3、拓展方式注入

我们可以使用p命名空间和c命名空间进行注入

官方解释

  • prototype原型模式:每次从容器中get的时候都会产生一个新对象

    <bean id="user2" class="com.lmq.pojo.User" c:name="大米" c:age="20" scope="prototype"/>
    

  • 其余的request、session、application、这些个只能在web中开发使用

  • 7、bean的自动装配

    • 自动装配是Spring满足bean依赖一种方式!
    • Spring会在上下文自动寻找,并自动给bean装配属性!

    在spring中有三种装配的方式

    1. 在xml中显示的配置
    2. 在java中显示配置
    3. 隐式的自动装配bean 【重要】、

    7.1、 测试

    1. 环境搭建
      • 一个人有两个宠物
      • 三个类 人 动物1 动物2
      • 装配到beans
      • 测试

    7.2、 ByName自动装配

    <!--
            byName:会自动在容器上下文中查找和自己对象set 方法后面的值对应的 beanid!
            byType:会自动在容器上下文中查找和自己对象属性类型相同的bean!
    -->
    <bean id="people" class="com.lmq.pojo.People" p:name="小刘" autowire="byName"/>
    

    7.3、 ByType自动装配

    <bean class="com.lmq.pojo.Cat"/>
    <bean class="com.lmq.pojo.Dog"/>
    
    <bean id="people" class="com.lmq.pojo.People" p:name="小刘" autowire="byType"/>
    

    小结

    • byName的时候,需要保证所有bean的id唯一,并且这个bean需要和自动注入的属性的方法的值一致!
    • byType的时候,需要保证所有bean的class唯一,并且这个bean需要和自动注入的属性的类型一致!

    7.4、使用注解实现自动装配

    jdk1.5支持的注解 spring2.5支持注解

    The introduction of annotation-based configuration raised the question of whether this approach is “better” than XML.

    要使用注解须知:

    1. 导入约束 context约束

      xmlns:context="http://www.springframework.org/schema/context"

    2. 配置注解的支持:context:annotation-config/

      <?xml version="1.0" encoding="UTF-8"?>
      <beans xmlns="http://www.springframework.org/schema/beans"
          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
          xmlns:context="http://www.springframework.org/schema/context"
          xsi:schemaLocation="http://www.springframework.org/schema/beans
              https://www.springframework.org/schema/beans/spring-beans.xsd
              http://www.springframework.org/schema/context
              https://www.springframework.org/schema/context/spring-context.xsd">
      
          <context:annotation-config/>
      
      </beans>
      

    @Autowired

    直接在属性上使用 使用后可以忽略set方法!也可以在set方法上使用

    使用Autowired我们可以不写set方法了,青提是你这个自动装配的属性在IOC(spring) 容器中存在,且符合名字byName!

    科普:

    @Nullable   //字段标记了这个注解 说明这个字段可以为null 在set传参前使用
    

    @Autowrired(required = false)  //如果定义了Autowired的required属性为false,说明这个对象可以为null 否则不能为空
    

    组合使用: 环境比较复杂 无法通过一个注解@Autowired完成时可以使用@Qualifier(value = "dog222")

    package com.lmq.pojo;
    
    import lombok.AllArgsConstructor;
    import lombok.Data;
    import lombok.NoArgsConstructor;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.beans.factory.annotation.Qualifier;
    
    /**
     * @author 羡鱼
     * @version 1.0
     * @date 2023/6/23 23:53
     */
    @Data
    @AllArgsConstructor
    @NoArgsConstructor
    public class People {
        @Autowired
        public Cat cat;
        @Autowired
        @Qualifier(value = "dog222")
        private Dog dog;
        private String name;
    }
    
    

    @Resource注解

    @Data
    @AllArgsConstructor
    @NoArgsConstructor
    public class People {
        @Resource
        public Cat cat;
        @Resource(name = "dog222")
        private Dog dog;
        private String name;
    }
    

    小结:

    @Resource 和 Autowired 的区别:

    • 都是用来自动装配的,都可以放在属性字段上
    • @Autowired通过byType的方式实现 而且必须要求这个对象存在 【常用】
    • @Resource默认通过byName的方式实现,如果找不到名字,则通过byType实现 如果两个都找不到就报错!【常用】
    • 执行顺序不同 @Autowired通过byType的方式实现,@Resource默认通过byName的方式实现。

    8、使用注解开发

    末尾

    热门相关:洪荒二郎传   花月颂   民国之文豪崛起   花月颂   花月颂