Spring-01

内容

  • Spring概念
  • Spring快速入门
  • Spring的IoC 和 DI
  • Bean基本配置
  • Bean生命周期
  • Bean实例化
  • Bean注入

1. Spring概念

1.1 概念

  • Spring是分层的JavaSE/EE应用 full-stack轻量级开源框架

1.2 Spring全家桶

目前学习的是Spring Framework，是Spring全家桶的基础。

1.3 Spring体系

  • Spring体系结构图

  • SSM的提供的解决方案

    • Mybatis：Dao层框架
    • SpringMVC：web层框架
    • Spring：软件三层中都可以看到Spring的应用场景

1.4 发展历程

  • Spring之父 Rod Johnson
  • EJB Enterprise Java Bean，sun公司提出来的大型web项目的架构
  • Expert One-on-One J2EE Design and Development 2002年 手把手教你怎么使用EJB开发大型web项目
  • Expert one-on-one J2EE Development without EJB 2004 手把手教你怎么不使用EJB开发大型web项目 （Spring的原型）
  • 官网：https://spring.io/projects
  • 课堂版本5.x

1.5 Spring优势

  • 方便解耦，简化开发

  • 方便集成各种优秀框架（不排斥、慢慢整合）

  • AOP（面向切面编程）编程的支持

  • 声明式事务的支持

  • Java源码是经典学习范例

  • 方便程序的测试（Spring整合junit）

1.6 Spring两大核心思想

  • IoC：Inverse of Control 控制反转 ，目的：解耦

  • AOP：Aspect Oriented Programming 面向切面编程

  • Spring演化过程

    基于接口编程：service和dao之间高度耦合

    工厂+配置文件：解除了耦合，留下配置文件和dao/工厂耦合，这种耦合是我们期望的一种耦合方式

  • IoC 控制反转

  • Inverse of Control

    把对象的创建权、依赖的注入权从程序员手中，反转到了Spring容器创建并提供

2. Spring quick Start

2.0 准备工作：配置私服

2.1 IOC实现步骤

  1. 导入Spring依赖坐标：spring-context-5.2.10.RELEASE
  2. 编写service/dao接口和实现类
  3. Spring核心配置文件中配置service/dao实现类
  4. 测试类中创建Spring容器对象，并通过对象获取service/dao实现类对象
  5. 调用service/dao实现类对象的方法测试

2.1.1 配置依赖坐标

新建模块/导入模块


    
    
        org.springframework
        spring-context
        5.2.10.RELEASE

2.1.2 编写service/dao实现类和接口

BookDao.java接口

package com.cy.dao;

public interface BookDao {
    public void save();
}

BookDaoImpl.java实现类

package com.cy.dao.impl;

import com.cy.dao.BookDao;

public class BookDaoImpl implements BookDao {
    public void save() {
        System.out.println("book dao save ...");
    }
}

BookService接口

package com.cy.service;

public interface BookService {
    public void save();
}

BooKServiceImpl实现类

package com.cy.service.impl;

import com.cy.dao.BookDao;
import com.cy.dao.impl.BookDaoImpl;
import com.cy.service.BookService;

public class BookServiceImpl implements BookService {

    private BookDao bookDao = new BookDaoImpl();

    public void save() {
        System.out.println("book service save ...");
        bookDao.save();
    }
}

2.1.3 新建Spring的配置文件并配置

resources 右键 选择 new--》xml configration file --》Spring config（前提是Spring的依赖已经成功导入）

配置文件名称任意，习惯写法applicationcontext.xml。本案中使用beans.xml

<?xml version="1.0" encoding="UTF-8"?>

2.1.4 创建Spring容器对象并获取bean对象

/**
 * @Description: 测试Spring容器创建和获取对象
 */
package com.cy;

import com.cy.dao.BookDao;
import com.cy.service.BookService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class App2 {
    public static void main(String[] args) {
        //3.获取IoC容器
        ApplicationContext ctx = new ClassPathXmlApplicationContext("beans.xml");
        //4.获取bean（根据bean配置id获取）
//        BookDao bookDao = (BookDao) ctx.getBean("bookDao");
//        bookDao.save();

        BookService bookService = (BookService) ctx.getBean("bookService");
        bookService.save();

    }
}

2.2 DI实现步骤

2.2.1 DI概念

全称：Dependency Injection。Service用到dao，Service就依赖了Dao，就需要把Dao注入到Service中。

之前的注入方式：

  • 之前Service中的dao都是我们自己new的；

使用Spring中的依赖注入

  • 我们就不需要自己new，Spring会自动找到(创建)Dao对象，并设置给Service中的成员变量。

2.2.2 实现步骤

  1. 基于IoC快速入门代码，完成下面操作。
  2. 删除被依赖对象的new创建代码，并提供setter
  3. Spring配置文件中配置依赖关系

2.2.3 修改代码

BookServiceImpl.java

public class BookServiceImpl implements BookService {
    //5.删除业务层中使用new的方式创建的dao对象
    private BookDao xxx;

    public void save() {
        System.out.println("book service save ...");
        xxx.save();
    }
    //6.提供对应的set方法
    public void setBookDao(BookDao xxx) {
        this.xxx = xxx;
    }
}

2.2.4 修改配置

其他代码保持不变，直接运行测试方法即可。

3. Spring配置-Bean标签

3.1 id&class属性

  • id：唯一标识，同一个Spring容器中不允许重复
  • class：全限定类名，用于反射创建对象

XML配置

<?xml version="1.0" encoding="UTF-8"?>

测试代码

/**
 * @Description: 测试Spring容器创建和获取对象
 */
public class UserServiceImpl {

    public static void main(String[] args) {

        // 创建容器对象，并加载配置文件
        ApplicationContext app = new ClassPathXmlApplicationContext("beans.xml");

        // 从容器对象中获取bean对象
        BookDao bookDao = (BookDao) app.getBean("bookDao");

        // 使用获取的bean对象
        bookDao.save();
    }
}

3.2 name 属性

为bean其别名，可以配置多个值，多个值之间使用空格/逗号/分号分隔

  • XML配置

    <?xml version="1.0" encoding="UTF-8"?>

  • 演示代码

    package com.cy;

import com.cy.dao.BookDao;
import com.cy.service.BookService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class AppForName {
    public static void main(String[] args) {

        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");

        // 可以通过bean标签name属性的值，获取对应的bean对象
        // BookService bookService = (BookService) ctx.getBean("service");
        
        // 如果传递参数不能成功匹配id和name的值，则会报错。NoSuchBean***
        BookService bookService = (BookService) ctx.getBean("service");

        bookService.save();
    }
}

3.3 scope 属性

这个很重要，但是一般使用默认值，单例！

  • 概念：单例：在整个项目中，某个类的对象有且仅有一个，这种情况，就是单(个实)例。

  • Spring中的Bean默认是单例的。

  • XML配置

    <?xml version="1.0" encoding="UTF-8"?>

  • 演示代码

    package com.cy;

import com.cy.dao.BookDao;
import com.cy.service.BookService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class AppForScope {
    public static void main(String[] args) {

        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");

        BookDao bookDao1 = (BookDao) ctx.getBean("bookDao");
        BookDao bookDao2 = (BookDao) ctx.getBean("bookDao");
        System.out.println(bookDao1);
        System.out.println(bookDao2);


    }
}

  • Spring可以帮我们维护已有项目中哪些类和对象

    可以单例的

    • Dao
    • Service
    • Servlet/Controller
    • Utils

    不是单例的一般不会让Spring维护

    • 实体类（数据传输的载体）

4. Bean的实例化

4.1 Spring之前对象实例化方式

  • 方式1：通过构造方法直接创建

    // 方式1：通过构造方法直接创建
BookDaoImpl bookDao = new BookDaoImpl();

  • 方式2：实例工厂方式

    /* 工厂类 */
public class BookDaoImplFactory {
    // 提供方法，返回一个BookDaoImpl的对象
    public BookDaoImpl getObject(){
        // 假装这里有非常复杂的流程
        return new BookDaoImpl();
    }
}


    /** 测试代码***/
// 方式2：实例工厂方式
// 2.1 创建工厂对象
BookDaoImplFactory factory = new BookDaoImplFactory();
// 2.2 通过工厂对象获取目标对象
BookDaoImpl booDao1 = factory.getObject();

  • 方式3：静态工厂方式

    /* 静态工厂类 */
class BookDaoImplFactoryStatic {
    // 提供静态方法，返回一个BookDaoImpl的对象
    public static BookDaoImpl getObject(){
        // 假装这里有非常复杂的流程
        return new BookDaoImpl();
    }
}


    // 方式3：静态工厂方式
BookDaoImpl bookDao2 = BookDaoImplFactoryStatic.getObject();

4.2 Spring中构造方法实例化

  • 快速入门案例中，Spring使用的就是通过反射无参构造创建的对象。

  • 无参构造

    OrderDao OrderDao2 = new OrderDaoImpl();

    对应Spring中的配置

  • 如果未提供给无参构造方法，会因为找不到该方法而报错。NoSuchMethodException *** init()

4.3 Spring中静态工厂实例化

  • 静态工厂

    // 方式3：静态工厂方式
OrderDao OrderDao2 = OrderDaoFactory.getOrderDao();

    对应Spring中配置

    从Spring容器中，获取方式和之前一样，通过id获取对象并使用。

  • 应用场景

    1. 兼容老的项目
    2. 创建过程比较复杂的对象，一般都是使用工厂模式

4.4 Spring中实例工厂实例化

  • 实例工厂

    // 方式3：实例工厂方式
// 创建工厂对象
UserDaoFactory factory = new UserDaoFactory();
// 通过工厂对象，得到目标对象
UserDao userDao = factory.getUserDao();

    对应Spring中配置

    从Spring容器中，获取方式和之前一样，通过id获取对象并使用。

4.5 Spring中FactoryBean实例化

  • 该方式是在第三种方法的简化改良。编码基本雷同，配置相对简单。

  • 实现步骤

    1. 编写工厂类实现FactoryBean。类名一般为xxxFactoryBean，泛型为目标对象类型xxx
    2. 实现getObject()方法、getObjectType()方法。
    3. Spring配置文件中简单配置。

  • xxxFactoryBean

    package com.cy.factory;

import com.cy.dao.UserDao;
import com.cy.dao.impl.UserDaoImpl;
import org.springframework.beans.factory.FactoryBean;
//FactoryBean创建对象
public class UserDaoFactoryBean implements FactoryBean {
    //代替原始实例工厂中创建对象的方法
    public UserDao getObject() throws Exception {
        return new UserDaoImpl();
    }

    public Class<?> getObjectType() {
        return UserDao.class;
    }
    /**
     *  该方法一般不用重写 
     *  决定获取的Bean是否为单例。默认返回true。
     *  true 单例          singleton
     *  false 多例（非单例） prototype
     * @return
     */
    public boolean isSingleton() {
        return true;
    }
}

  • XML配置

  • 应用场景

    Spring在整合其他框架时，多用该方式。

5 生命周期

生命周期：对象从出生到死亡的整个过程。

5.1 配置实现

  1. 提前准备好两个方法，方法名任意 xxx yyy

    package com.cy.dao.impl;

import com.cy.dao.BookDao;

public class BookDaoImpl implements BookDao {
    public void save() {
        System.out.println("book dao save ...");
    }
    //表示bean初始化对应的操作
    public void xxx(){
        System.out.println("init...");
    }
    //表示bean销毁前对应的操作
    public void yyy(){
        System.out.println("destory...");
    }
}

  2. Spring配置文件对应bean标签上添加两个属性，属性值不用带小括号

5.2 实现接口

package com.cy.dao.impl;

import com.cy.dao.BookDao;

public class BookDaoImpl implements BookDao, InitializingBean, DisposableBean {
    public void save() {
        System.out.println("book dao save ...");
    }
    // 实现InitializingBean中抽象方法，该方法会在init-method指定的方法执行后执行
    public void afterPropertiesSet() throws Exception {
        System.out.println("service init");
    }
    
    // 实现DisposableBean充抽象方法
    public void destroy() throws Exception {
        System.out.println("service destroy");
    }
}

5.3 注意

需要手动关闭容器才能看到销毁代码的执行。

  • Spring容器关闭的功能，在Config***的子接口中规定的，需要向下转型到其子类才能调用，一般直接使用ClasspathXMLApplicationContext
  • 也可以注册关闭的钩子ctx.registerShutdownHook()，会在执行完代码后自动关闭。

5.4 声明周期(11步)

  • 初始化容器
    • 创建Bean对象（内存分配）
    • 执行构造方法
    • 执行属性注入（set操作）
    • 执行bean初始化方法
  • 使用bean
    • 执行业务操作
  • 关闭/销毁容器
    • 执行bean销毁方法

6. 依赖注入

6.1 概念

Dependency Injection，DI

依赖：在A类中用到了B类，就说A依赖B，需要在A类中添加一个B类型的成员变量；

依赖注入：把B类对象设置进A中B类型的成员变量的过程，称为依赖注入。

Spring会把B类对象注入到A类中B类型的属性上。自动完成注入。

// 伪代码演示
class A{
	// 为B类型的b变量初始化的过程，称为依赖注入
	B b;
}

依赖注入可以理解成IoC的一种应用场景，反转的是对象间依赖关系维护注入权。

6.2 IoC和DI的关系(面试题)

IoC是一种思想（规范），可以把对象的创建权、对象间依赖关系的维护注入权等从程序员手中，反转到了Spring容器中；

DI依赖注入，只是IoC在某个方面的一个具体实现，在 依赖关系维护注入 方面的一个实现。

6.3 注入方式

本质上就是为某个类的成员变量赋值的方式：setter/有参构造

/*
    1. 提供有参构造方法，通过构造方法在创建对象的同时为成员变量赋值
    2. 提供setter，通过setter为成员变量赋值
*/

6.4 Setter方式注入

注入引用类型（容器中已经存在的其他Bean对象）

  1. 保证被注入的Bean和目标Bean都已经装配到Spring容器

  2. 在BookServiceImpl类中添加UserDao/BookDao的属性并提供setter

    package com.cy.service.impl;

import com.cy.dao.BookDao;
import com.cy.dao.UserDao;
import com.cy.service.BookService;

public class BookServiceImpl implements BookService{
    private BookDao bookDao;
    private UserDao userDao;
    //setter注入需要提供要注入对象的set方法
    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }
    //setter注入需要提供要注入对象的set方法
    public void setBookDao(BookDao bookDao) {
        this.bookDao = bookDao;
    }

    public void save() {
        System.out.println("book service save ...");
        bookDao.save();
        userDao.save();
    }
}

  3. 通过子标签完成注入

注入简单数据类型数据

String + 基本数据类型

只需要把生面的配置文件中ref属性换成value属性即可。



    
    
    
    
    



package com.cy.dao.impl;

import com.cy.dao.BookDao;

public class BookDaoImpl implements BookDao {

    private String databaseName;
    private int connectionNum;
    //setter注入需要提供要注入对象的set方法
    public void setConnectionNum(int connectionNum) {
        this.connectionNum = connectionNum;
    }
    //setter注入需要提供要注入对象的set方法
    public void setDatabaseName(String databaseName) {
        this.databaseName = databaseName;
    }

    public void save() {
        System.out.println("book dao save ..."+databaseName+","+connectionNum);
    }
}

6.5 构造器注入

不常用

  • 被装配的类中提供有参构造，而不需要提供setter

    package com.cy.service.impl;

import com.cy.dao.BookDao;
import com.cy.dao.UserDao;
import com.cy.service.BookService;

public class BookServiceImpl implements BookService{
    private BookDao bookDao;
    private UserDao userDao;

    // 有参构造，不需要提供setter
    public BookServiceImpl(BookDao bookDao, UserDao userDao) {
        this.bookDao = bookDao;
        this.userDao = userDao;
    }

    public void save() {
        System.out.println("book service save ...");
        bookDao.save();
        userDao.save();
    }
}

  • XML中通过子标签配置constructor-arg

  • value属性注入简单类型

6.6 自动装配

自动为当前Bean完成依赖注入，简称自动装配，可取值byName | byType | constructor，分别代表按照

  1. byType：按照属性类型和Spring容器中bean进行匹配，完成自动装配注入
  2. byName：按照属性名和Spring容器中bean的id进行匹配，完成自动装配注入
  3. constructor：按照构造方法的形参类型和Spring容器中bean进行匹配，完成自动装配注入

注意：上述中属性值的是setter或者是构造形参，而非成员变量本身。

xml中配置：把所有的Bean都配置进Spring容器。

java代码

package com.cy.service.impl;

import com.cy.dao.BookDao;
import com.cy.service.BookService;

public class BookServiceImpl implements BookService{
    private BookDao bookDao;

    public void setBookDao(BookDao bookDao) {
        this.bookDao = bookDao;
    }

    public void save() {
        System.out.println("book service save ...");
        bookDao.save();
    }
}

6.7 注意事项

  1. 优选自动装配
  2. 使用按类型装配时（byType）必须保障容器中相同类型的bean唯一，推荐使用
  3. 使用按名称装配时（byName）必须保障容器中具有指定名称的bean，因变量名与配置耦合，不推荐使用
  4. 自动装配优先级低于setter注入与构造器注入，同时出现时自动装配配置失效

6.8 集合注入

了解即可。



    
 
    
    
        
            100
            200
            300
        
    
    
    
        
            china
            henan
            kaifeng
        
    
    
    

        
            
            
            
        
    



package com.cy.dao.impl;

import com.cy.dao.BookDao;

import java.util.*;

public class BookDaoImpl implements BookDao {

    private String[] array;

    private List list;

    private Set set;

    private Map map;

    private Properties properties;

    public void setArray(String[] array) {
        this.array = array;
    }

    public void setList(List list) {
        this.list = list;
    }

    public void setSet(Set set) {
        this.set = set;
    }

    public void setMap(Map map) {
        this.map = map;
    }

    public void setProperties(Properties properties) {
        this.properties = properties;
    }

    public void save() {
        System.out.println("book dao save ...");

        System.out.println("遍历数组:" + Arrays.toString(array));

        System.out.println("遍历List" + list);

        System.out.println("遍历Set" + set);

        System.out.println("遍历Map" + map);

        System.out.println("遍历Properties" + properties);
    }
}

7. 案例练习

无论是自己写的类要装配进Spring容器，还是第三方的类要装配进Spring容器，只需要遵循Spring的配置规则即可。

后者与前者的不同，仅仅是把自己编写代码变成了导入依赖坐标，配置方式一致。

7.1 DruidDataSource

7.1.1 导入依赖坐标

<?xml version="1.0" encoding="UTF-8"?>

    4.0.0

    com.cy
    ssm01_spring01_11_datasource
    1.0-SNAPSHOT

    
        
            org.springframework
            spring-context
            5.2.10.RELEASE
        
  		
            com.alibaba
            druid
            1.1.16

7.1.2 Spring装配配置

7.1.3 测试

package com.itheima;

import com.itheima.dao.BookDao;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import javax.sql.DataSource;

public class App {
    public static void main(String[] args) {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
        DataSource dataSource = (DataSource) ctx.getBean("dataSource");
        System.out.println(dataSource);
    }
}

7.2 C3P0数据源

老牌数据源管理工具，曾经久不衰。

7.2.1 导入依赖坐标

<?xml version="1.0" encoding="UTF-8"?>

    4.0.0

    com.itheima
    ssm01_spring01_11_datasource
    1.0-SNAPSHOT

    
        
            org.springframework
            spring-context
            5.2.10.RELEASE
        
        
            c3p0
            c3p0
            0.9.1.2
        
        
            mysql
            mysql-connector-java
            5.1.47

7.2.2 Spring装配配置

7.2.3 测试

package com.cy;

import com.cy.dao.BookDao;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import javax.sql.DataSource;

public class App {
    public static void main(String[] args) {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
        DataSource dataSource = (DataSource) ctx.getBean("dataSource");
        System.out.println(dataSource);
    }
}

8 引入properties文件

8.1 创建properties文件

  • jdbc.properties

    # 不要使用username，否则会错误的获取到当前系统的用户名。建议使用jdbc.username
jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://127.0.0.1:3306/spring_db
jdbc.username=root
jdbc.password=root

8.2 beans.xml文件引入 jdbc.properties文件

8.3 代码测试

package com.cy;

import com.cy.dao.BookDao;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import javax.sql.DataSource;

public class App {
    public static void main(String[] args) {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
        BookDao bookDao = (BookDao) ctx.getBean("bookDao");
        bookDao.save();
    }
}
Spring

相关

微信小程序+SpringBoot(Shiro)登录后，调用接口还是跑到了login。

eclipse搭建springboot开发环境

springboot学习之路31（整合minio服务）

Springboot配置tk-mybatis

springboot配置信息

Java web开发：从零到 Run 一个现有的 Spring Boot 前后端分离项目（前端Vue）

SpringMVC的请求和响应ModelAndView,Model,ResponseBody

SpringMVC、SpringMVC XML配置（纯XML方式）

SpringAOP[3]-Cglib代理流程分析

jdbc,jpa,springjdbc，springdatajpa,mybatis之间的区别

springboot配置国际化功能

SpringBoot AOP+自定义注解实现日志功能

标签