Spring学习笔记01

1.Spring概述

1.1 简介

Spring学习笔记01 - 图1

Spring :春天——> 给软件行业带来了春天

2002年，Rob Jahnson首次推出了Spring框架原型interface21框架

2004年3月24日，Spring框架以interface21框架为基础，经过重新设计，发布了1.0正式版

Spring理念：使现有技术更加实用，整合现有的框架技术

官网：https://spring.io/

官方文档： https://docs.spring.io/spring-framework/docs/current/spring-framework-reference/

官方下载地址：https://repo.spring.io/release/org/springframework/spring/

GitHub地址：https://github.com/spring-projects/spring-framework

优点：

  • Spring是一个免费开源的框架，容器
  • spring是一个轻量级的框架，非侵入式的
  • 控制反转IoC 面向切面 Aop
  • 对事务的支持，对框架的支持

总结：Spring是一个轻量级的控制反转（IoC）和面向切面（Aop）的容器（框架）

1.2 组成

Spring学习笔记01 - 图2

Spring框架是一个分层架构，由7个定义良好的模块组成，Spring模块构建在核心容器之上，核心容器定义了创建，配置，和管理bean的方式

Spring学习笔记01 - 图3

组成Spring框架的每个模块都可以单独存在，或者与其它一个或多个模块联合实现，每个模块的功能如下

  • 核心容器：核心容器提供Spring框架的基本功能，核心容器的主要组件是BeanFactory,他是工厂模式的实现

BeanFactory使用控制反转的模式（IoC）将应用程序的配置和依赖性规范与实际的应用程序代码公开

  • Spring 上下文：Spring 上下文是一个配置文件，向 Spring 框架提供上下文信息。Spring 上下文包括企业服务，例如 JNDI、EJB、电子邮件、国际化、校验和调度功能。
  • Spring AOP: 通过配置管理特性，Spring AOP模式直接将面向切面的编程功能，集成到了Spring框架中，所以，可以很容易的使Spring框架管理任何支持AOP的对象，Spring AOP模块为基于Spring的应用程序中的对象提供了事务管理服务，通过使用Spring AOP，不用依赖组件，就可以将声明性事务管理集成到应用程序中
  • Spring DAO: JDBC DAO 抽象层提供了有意义的异常层次结构，可用该结构来管理异常处理和不同数据库供应商抛出的错误消息。异常层次结构简化了错误处理，并且极大地降低了需要编写的异常代码数量（例如打开和关闭连接）。Spring DAO 的面向 JDBC 的异常遵从通用的 DAO 异常层次结构。
  • Spring ORM:Spring 框架插入了若干个 ORM 框架，从而提供了 ORM 的对象关系工具，其中包括JDO、Hibernate 和 iBatis SQL Map。所有这些都遵从 Spring 的通用事务和 DAO 异常层次结构。
  • Spring Web 模块：Web 上下文模块建立在应用程序上下文模块之上，为基于 Web 的应用程序提供了上下文。所以，Spring 框架支持与 Jakarta Struts 的集成。Web 模块还简化了处理多部分请求以及将请求参数绑定到域对象的工作。
  • Spring MVC框架：MVC框架是一个全功能的构建Web应用程序的MVC实现，通过策略接口，MVC框架变成为高度可配置的，MVC容纳了大量视图技术，其中包括JSP、Velocity、iText和POI

1.3 拓展

Spring Boot与Spring Cloud

  • Spring Boot是spring的一套快速配置脚手架，可以基于Spring Boot快速开发单个微服务
  • Spring Cloud是基于Spring Boot 实现的
  • Spring Boot专注与快速、方便集成的单个微服务个体，Spring Cloud关注全局的服务治理框架
  • Spring Boot使用了约束优于配置的理念，很多集成方案已经帮你选择好了，能不配置就不配置，Spring Cloud很大的一部分是基于Spring Boot来实现的，Spring Boot可以离开Spring Cloud独立使用开发项目，但是Spring Cloud 离不开Spring Boot，属于依赖的关系
  • Spring Boot 在SpringCloud中起到了承上启下的作用，如果要学习Spring Cloud 必须要学习Spring Boot

2.IOC理论指导

2 .1 IOC基础

新建一个maven项目

先用之前的方式写一个项目

1.先写一个UserDao 接口

  1. package com.jcsune.dao;
  2. public interface UserDao {
  3.     void getUser();
  4. }

2.再去写Dao的实现类

  1. package com.jcsune.dao;
  2. public class UserDaoImpl implements UserDao {
  3.     public void getUser() {
  4.         System.out.println("默认获取用户的数据");
  5.     }
  6. }

3.接着写UserService的接口

  1. package com.jcsune.service;
  2. public interface UserService {
  3.     public void getUser();
  4. }

4.接着写UseService的实现类

  1. package com.jcsune.service;
  2. import com.jcsune.dao.UserDao;
  3. import com.jcsune.dao.UserDaoImpl;
  4. public class UserServiceImpl  implements UserService{
  5.     private UserDao userDao=new UserDaoImpl() ;
  6.     public void getUser() {
  7.         userDao.getUser();
  8.     }
  9. }

5.测试

  1. import com.jcsune.service.UserService;
  2. import com.jcsune.service.UserServiceImpl;
  3. import org.junit.Test;
  4. public class MyTest {
  5.       @Test
  6.           public void test() {
  7.             UserService service= new UserServiceImpl();
  8.             service.getUser();
  9.         }
  10.     }

6.运行结果

Spring学习笔记01 - 图4

7.如果我们把UserDao的实现类增加一个UserDaoMysqlImpl

  1. package com.jcsune.dao;
  2. public class UserDaoMysqlImpl implements UserDao {
  3.     public void getUser() {
  4.         System.out.println("Mysql获取用户数据");
  5.     }
  6. }

8.我们如果要去使用Mysql的话，我们就需要去service的实现类里面修改对应的实现

  1. import com.jcsune.dao.UserDao;
  2. import com.jcsune.dao.UserDaoImpl;
  3. import com.jcsune.dao.UserDaoMysqlImpl;
  4. public class UserServiceImpl  implements UserService{
  5.     /*private UserDao userDao=new UserDaoImpl() ;*/
  6.     private UserDao userDao=new UserDaoMysqlImpl();
  7.     public void getUser() {
  8.         userDao.getUser();
  9.     }
  10. }

9.测试结果（这时测试代码不用修改）

Spring学习笔记01 - 图5

接着如果我们要使用Oracle,又需要去service实现类里面修改对应的实现万一需求大的话，这种方式根本不适用，耦合性太高，牵一发儿动全身

10.解决方法

  • 首先新增一个UserDao的实现类UserDaoOracleImpl
  1. package com.jcsune.dao;
  2. public class UserDaoOracleImpl implements UserDao {
  3.     public void getUser() {  
  4.     }
  5. }
  • 我们在需要用到它的地方，不去实现它，而是留出一个接口，利用set
  1. package com.jcsune.service;
  2. import com.jcsune.dao.UserDao;
  3. import com.jcsune.dao.UserDaoImpl;
  4. import com.jcsune.dao.UserDaoMysqlImpl;
  5. public class UserServiceImpl  implements UserService{
  6.     /*private UserDao userDao=new UserDaoImpl() ;*/
  7.     /*private UserDao userDao=new UserDaoMysqlImpl();*/
  8.     private UserDao userDao;
  9.     //利用set实现
  10.     public void setUserDao(UserDao userDao) {
  11.         this.userDao = userDao;
  12.     }
  13.     public void getUser() {
  14.         userDao.getUser();
  15.     }
  16. }
  • 最后去测试类中进行测试（此时测试代码需要更改）
  1. import com.jcsune.dao.UserDaoOracleImpl;
  2. import com.jcsune.service.UserService;
  3. import com.jcsune.service.UserServiceImpl;
  4. import org.junit.Test;
  5. public class MyTest {
  6.       @Test
  7.           public void test() {
  8.             UserService service= new UserServiceImpl();
  9.             service.setUserDao(new UserDaoOracleImpl());
  10.             service.getUser();
  11.         }
  12.     }

Spring学习笔记01 - 图6

没使用set之前，所有的东西都是由程序去进行控制创建，而使用set之后由我们自行控制创建对象，把主动权交给了调用者，程序不用去管怎么创建，怎么实现的了，它只负责提供一个接口，这种思想从本质上解决了问题，程序员不用去管对象的创建的了，更多的去关注业务的实现，耦合性大大降低，这也就是IOC的原型

2.2 IOC本质

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

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

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

Spring学习笔记01 - 图7

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

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

3.HelloSpring

3.1 HelloSpring

新建一个maven项目，导入jar包

注：Spring需要导入commons-logging进行日志记录，我们利用maven，它会自动下载对应的依赖项

  1. <!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
  2.         <dependency>
  3.             <groupId>org.springframework</groupId>
  4.             <artifactId>spring-webmvc</artifactId>
  5.             <version>5.1.10.RELEASE</version>
  6.         </dependency>

1.编写一个Hello实体类

  1. package com.jcsune.pojo;
  2. public class Hello {
  3.     private String name;
  5.     public String getName() {
  6.         return name;
  7.     }
  8.     public void setName(String name) {
  9.         this.name = name;
  10.     }
  11.     public void show(){
  12.         System.out.println("Hello,"+name);
  13.     }
  14. }

2.编写spring文件，这里我们可以命名为beans.xml

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.        xsi:schemaLocation="http://www.springframework.org/schema/beans
  5.         https://www.springframework.org/schema/beans/spring-beans.xsd">
  6. <!--bean就是java对象，由Spring创建和管理-->
  7.     <bean id="hello" class="com.jcsune.pojo.Hello">
  8.         <property name="name" value="Spring"/>
  9.     </bean>
  10. </beans>

3.进行测试

  1. import com.jcsune.pojo.Hello;
  2. import org.springframework.context.ApplicationContext;
  3. import org.springframework.context.support.ClassPathXmlApplicationContext;
  4. public class MyTest {
  5.     public static void main(String[] args) {
  6.         //解析beans.xml文件，生成管理对应的Bean对象
  7.        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
  8.        //getBean:参数即为spring配置文件中bean的id
  9.         Hello hello=(Hello) context.getBean("hello");
  10.         hello.show();
  11.     }
  12. }

4.结果

Spring学习笔记01 - 图8

思考

  • Hello对象是由谁创建的？ 答：Hello对象是由Spring创建的
  • Hello对象的属性是怎么设置的？ 答：hello对象的属性是由Spring容器设置的，这个过程就叫控制反转
  • 控制：谁来控制对象的创建，传统应用程序的对象是由程序本身控制创建的，使用Spring后，对象是由Spring来创建的
  • 反转：程序本身不创建对象，而变成被动的接收对象

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

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

3.2 IoC创建对象的方式

通过无参构造方法来创建

  1. User.java
  1. package com.jcsune.pojo;
  3. public class User {
  4.     private String name;
  5.     public User(){
  6.         System.out.println("user无参构造方法");
  7.     }
  9.     public String getName() {
  10.         return name;
  11.     }
  13.     public void setName(String name) {
  14.         this.name = name;
  15.     }
  16.     public void show(){
  17.         System.out.println("name="+name);
  18.     }
  19. }
  1. beans.xml
  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.        xsi:schemaLocation="http://www.springframework.org/schema/beans
  5.         https://www.springframework.org/schema/beans/spring-beans.xsd">
  7.     <bean id="user" class="com.jcsune.pojo.User">
  8.         <property name="name" value="jcsune"/>
  10.     </bean>
  12. </beans>
  1. 测试类
  1. import com.jcsune.pojo.User;
  2. import org.junit.Test;
  3. import org.springframework.context.ApplicationContext;
  4. import org.springframework.context.support.ClassPathXmlApplicationContext;
  6. public class MyTest {
  7.     @Test
  8.     public void test(){
  9.         ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
  10.        //在执行getBean的时候，user已经创建好了，通过无参构造
  11.        User user = (User)context.getBean("user");
  12.        //调用对象的方法
  13.         user.show();
  14.     }
  16. }
  1. 结果

Spring学习笔记01 - 图9

通过有参构造方法来编写

  1. UserT.java
  1. package com.jcsune.pojo;
  3. public class UserT {
  4.     private String name;
  5.     public UserT(String name){
  6.         this.name=name;
  7.     }
  9.     public String getName() {
  10.         return name;
  11.     }
  13.     public void setName(String name) {
  14.         this.name = name;
  15.     }
  16.     public void show(){
  17.         System.out.println("name="+name);
  18.     }
  19. }
  1. bean.xml有三种方式来编写
  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.        xsi:schemaLocation="http://www.springframework.org/schema/beans
  5.         https://www.springframework.org/schema/beans/spring-beans.xsd">
  7. <!--<bean id="user" class="com.jcsune.pojo.User">-->
  8. <!--    <property name="name" value="jcsune"/>-->
  10. <!--</bean>-->
  11. <!--    第一种根据index参数下标设置-->
  12.     <bean id="userT" class="com.jcsune.pojo.UserT">
  13. <!--        index指构造方法，下标从0开始-->
  14.         <constructor-arg index="0" value="jcsune2"/>
  16.     </bean>
  17. <!--    第二种根据参数名字来设置-->
  18. <bean id="userT" class="com.jcsune.pojo.UserT">
  19. <!--    name指参数名-->
  20.     <constructor-arg name="name" value="jcsune2"/>
  21. </bean>
  22. <!--    第三种根据参数类型设置-->
  23.     <bean id="userT" class="com.jcsune.pojo.UserT">
  24.         <constructor-arg type="java.lang.String" value="jcsune2"/>
  25.     </bean>
  27. </beans>
  1. 测试
  1.  @Test
  2.     public void testT(){
  3.         ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
  4.         UserT userT=(UserT)context.getBean("userT");
  5.         userT.show();
  6.     }
  1. 结果

Spring学习笔记01 - 图10

3.3 Spring配置

1. 别名

alias 设置别名，为bean设置别名,在获取bean的时候可以使用别名获取

  1.  <alias name="userT" alias="ccsune"/>

2.Bean的配置

  1. <!--bean就是java对象,由Spring创建和管理-->
  2. <!--
  3.    id 是bean的标识符,要唯一,如果没有配置id,name就是默认标识符
  4.    如果配置id,又配置了name,那么name是别名
  5.    name可以设置多个别名,可以用逗号,分号,空格隔开
  6.    如果不配置id和name,可以根据applicationContext.getBean(.class)获取对象;
  8. class是bean的全限定名=包名+类名
  9. -->
  10. <bean id="hello" name="hello2 h2,h3;h4" class="com.kuang.pojo.Hello">
  11.    <property name="name" value="Spring"/>
  12. </bean>

3.import

团队的合作使用import来实现，它可以把多个配置文件合并为一个

  1. <import resource="{path}/beans.xml"/>

4.依赖注入

4.1 概念

  • 依赖注入(Dependency Injectiojn, DI)
  • 依赖：指Bean对象的创建依赖于容器。 Bean对象的依赖资源
  • 注入： 指Bean对象所依赖的资源，由容器来设置和装配

4.2 构造器注入

见 3.2 IoC创建对象的方式

4.3 Set注入（重点）

要求被注入的属性，必须有set方法，set方法的方法名是由set+属性首字母大写，如果属性是boolean类型，没有set方法。是is

测试类：

Address.java

  1. package com.jcsune.pojo;
  3. public class Address {
  4.     private String address;
  6.     public String getAddress() {
  7.         return address;
  8.     }
  10.     public void setAddress(String address) {
  11.         this.address = address;
  12.     }
  13. }

Student.java

  1. package com.jcsune.pojo;
  3. import java.util.*;
  5. public class Student {
  6.     private String name;
  7.     private Address address;
  8.     private String[] books;
  9.     private List<String> hobbies;
  10.     private Map<String,String> card;
  11.     private Set<String> games;
  12.     private String wife;
  13.     private Properties info;
  15.     public String getName() {
  16.         return name;
  17.     }
  19.     public void setName(String name) {
  20.         this.name = name;
  21.     }
  23.     public Address getAddress() {
  24.         return address;
  25.     }
  27.     public void setAddress(Address address) {
  28.         this.address = address;
  29.     }
  31.     public List<String> getHobbies() {
  32.         return hobbies;
  33.     }
  35.     public void setHobbies(List<String> hobbies) {
  36.         this.hobbies = hobbies;
  37.     }
  39.     public Map<String, String> getCard() {
  40.         return card;
  41.     }
  43.     public void setCard(Map<String, String> card) {
  44.         this.card = card;
  45.     }
  47.     public Set<String> getGames() {
  48.         return games;
  49.     }
  51.     public void setGames(Set<String> games) {
  52.         this.games = games;
  53.     }
  55.     public String getWife() {
  56.         return wife;
  57.     }
  59.     public void setWife(String wife) {
  60.         this.wife = wife;
  61.     }
  63.     public Properties getInfo() {
  64.         return info;
  65.     }
  67.     public void setInfo(Properties info) {
  68.         this.info = info;
  69.     }
  71.     public String[] getBooks() {
  72.         return books;
  73.     }
  75.     public void setBooks(String[] books) {
  76.         this.books = books;
  77.     }
  79.     @Override
  80.     public String toString() {
  81.         return "Student{" +
  82.                 "name='" + name + '\'' +
  83.                 ", address=" + address.getAddress() +
  84.                 ", books=" + Arrays.toString(books) +
  85.                 ", hobbies=" + hobbies +
  86.                 ", card=" + card +
  87.                 ", games=" + games +
  88.                 ", wife='" + wife + '\'' +
  89.                 ", info=" + info +
  90.                 '}';
  91.     }
  92. }

beans.xml

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.        xsi:schemaLocation="http://www.springframework.org/schema/beans
  5.         https://www.springframework.org/schema/beans/spring-beans.xsd">
  6.     <bean id="addr" class="com.jcsune.pojo.Address">
  7.         <property name="address"  value="河南"/>
  8.     </bean>
  10.     <bean id="student" class="com.jcsune.pojo.Student">
  11. <!--    常量注入-->
  12.     <property name="name" value="小明"/>
  13. <!--    Bean 注入-->
  14.     <property name="address" ref="addr"/>
  15. <!--    数组注入 -->
  16.     <property name="books">
  17.         <array>
  18.             <value>西游记</value>
  19.             <value>水浒传</value>
  20.             <value>红楼梦</value>
  21.         </array>
  22.     </property>
  23. <!--    List注入    -->
  24.     <property name="hobbies">
  25.         <list>
  26.             <value>听歌</value>
  27.             <value>打游戏</value>
  28.         </list>
  29.     </property>
  30. <!--    Map注入-->
  31.      <property name="card">
  32.          <map>
  33.              <entry key="中国邮政" value="5487745887"/>
  34.              <entry key="建设银行" value="4448785884"/>
  35.          </map>
  36.      </property>
  37. <!--    Set注入-->
  38.         <property name="games">
  39.             <set>
  40.                 <value>LOL</value>
  41.                 <value>CF</value>
  42.             </set>
  43.         </property>
  44. <!--     Null注入-->
  45.         <property name="wife"><null/></property>
  46. <!--     Properties注入-->
  47.         <property name="info">
  48.             <props>
  49.                 <prop key="学号">15401700214</prop>
  50.                 <prop key="性别">男</prop>
  51.                 <prop key="姓名">小明</prop>
  52.             </props>
  54.         </property>
  55. </bean>
  58. </beans>

测试类

  1. import com.jcsune.pojo.Student;
  2. import org.junit.Test;
  3. import org.springframework.context.ApplicationContext;
  4. import org.springframework.context.support.ClassPathXmlApplicationContext;
  6. public class MyTest {
  7.     @Test
  8.     public void test(){
  9.         ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
  10.         Student student=(Student)context.getBean("student");
  11.         System.out.println(student.toString());
  13.     }
  14. }

运行结果：

Spring学习笔记01 - 图11

4.5 p命名和c命名注入

User.java

  1. package com.jcsune.pojo;
  3. public class User {
  4.     private String name;
  5.     private int age;
  7.     public User() {
  9.     }
  11.     public User(String name, int age) {
  12.         this.name = name;
  13.         this.age = age;
  14.     }
  16.     public String getName() {
  17.         return name;
  18.     }
  20.     public void setName(String name) {
  21.         this.name = name;
  22.     }
  24.     public int getAge() {
  25.         return age;
  26.     }
  28.     public void setAge(int id) {
  29.         this.age= age;
  30.     }
  32.     @Override
  33.     public String toString() {
  34.         return "User{" +
  35.                 "name='" + name + '\'' +
  36.                 ", age=" + age +
  37.                 '}';
  38.     }
  39. }

beansuser.xml

Spring学习笔记01 - 图12

c就是所谓的构造器注入

测试：

  1. public void testT(){
  2.         ApplicationContext context = new ClassPathXmlApplicationContext("beansuser.xml");
  3.         User user=(User)context.getBean("user");
  4.         System.out.println(user.toString());
  5.         User user2=(User)context.getBean("user2");
  6.         System.out.println(user2.toString());
  7.     }

运行结果：

Spring学习笔记01 - 图13