Spring实战学习01----------之认识Bean

Spring

- Spring概念
- - 简介
  - 发展历程
  - 优势
- Spring的体系结构
- - Spring开发图示
  - Spring开发步骤
- Spring快速入门
- Spring配置文件 -Bean
- - Bean标签的基本配置
  - 什么是Bean?
  - Bean标签的范围取值
  - Bean生命周期配置
  - Bean实例化的三种方式
- Spring配置文件-依赖注入
- - 依赖注入
  - Bean的依赖注入方式
  - 依赖注入的数据类型
- 引入其他配置文件（分模块开发）
- Spring相关API

Spring概念简介

Spring是分层的 Java SE/EE应用 full-stack 轻量级开源框架，以 IoC（Inverse Of Control：反转控制）和 AOP（Aspect Oriented Programming：面向切面编程）为内核。

提供了展现层 SpringMVC和持久层 Spring JDBCTemplate以及业务层事务管理等众多的企业级应用技术，还能整合开源世界众多著名的第三方框架和类库，逐渐成为使用最多的Java EE 企业应用开源框架

发展历程

Rod Johnson （ Spring 之父）

2017 年
9 月份发布了 Spring 的最新版本 Spring5.0
通用版（GA）

优势

1、方便解耦，简化开发

通过Sping提供的IoC容器，可以将对象间的依赖关系交由Sping进行控制，避免编码所造成的过度耦合

2、AOP 编程的支持

通过Spring的AOP功能，方便进行面向切片编程，许多不容易传统OOP实现的功能可以通过AOP轻松实现

3、声明式事务的支持

可以将我们从单调烦闷的事务管理代码中解脱出来，通过声明方式灵活的进行事务管理，提高开发效率和质量

4、方便程序的测试

集成Junit进行程序测试

5、方便集成各种优秀框架

Spring对各种优秀框架（Struts,Hibemate、Hessian、Quartz等）的支持

6、降低了JavaEE API的使用难度

Spring对javaEE API（如JDBC、JavaMail、远程调用）进行了薄薄的封装层，是这些API的使用难度大为降低。

Spring的体系结构

Spring开发图示

Spring开发步骤

1、导入Spring开发的基本包坐标

2、编写Dao接口和实现类

3、创建Spring核心配置文件

4、创建Spring配置文件中配置UserDaoImpl

5、使用Spring的API获得Bean实例

Spring快速入门

1、导入Spring开发的基本包坐标


    
        org.springframework
        spring-context
        5.0.5.RELEASE

2、编写Dao接口和实现类

接口

public interface UserDao {
    public void save();
}

实现类

public class UserDaoImpl implements UserDao {
    @Override
    public void save() {
        System.out.println("do 		save......");
    }
}

3、创建Spring核心配置文件

4、创建Spring配置文件中配置UserDaoImpl

5、使用Spring的API获得Bean实例

public class UserDaoDemo {
    public static void main(String[] args) {
        ApplicationContext app = new ClassPathXmlApplicationContext("applicetionContext.xml");
        UserDao userDao = (UserDao) app.getBean("userDao");
        userDao.save();

    }

测试结果：

Spring配置文件 -Bean Bean标签的基本配置

用于配置对象交由Spring来创建

默认情况下他调用的是类中的无参构造函数，如果没有无参构造则不能创建成功。

基本属性：

id:Bean实例在Spring容器中的唯一标识

class:Bean的全限定名称

什么是Bean?

在 Spring 中，构成应用程序主干并由Spring IoC容器管理的对象称为bean。bean是一个由Spring IoC容器实例化、组装和管理的对象。

我们总结如下：
1.bean是对象，一个或者多个不限定
2.bean由Spring中一个叫IoC的东西管理
3.我们的应用程序由一个个bean构成

关于Bean的规范
1.所有属性为private
2.提供默认构造方法
3.提供getter和setter
4.实现serializable接口

Bean标签的范围取值

scope:值对象的作用范围，取值如下

取值范围	说明
singleton	默认值，单例的
prototype	多例的
request	WEB 项目中，Spring 创建一个 Bean 的对象，将对象存入到 request 域中
session	WEB 项目中，Spring 创建一个 Bean 的对象，将对象存入到 session 域中
global session	WEB 项目中，应用在 Portlet 环境，如果没有 Portlet 环境那么globalSession 相当于 session

1️⃣测试属性为singleton时是不是创建一个单例对象

1、修改属性值

2、编写测试类，定义不同名的两个对象并比较地址值，如果返回true则说明是单例

public void test1(){
    ApplicationContext app = new ClassPathXmlApplicationContext("applicetionContext.xml");
    UserDao userDao1 = (UserDao) app.getBean("userDao");
    UserDao userDao2 = (UserDao) app.getBean("userDao");
    System.out.println(userDao1.equals(userDao2));
}

打印结果

结论：是单例

2️⃣测试属性为prototype时是不是创建多例对象

1、修改属性值

2、编写测试类，定义不同名的两个对象并比较地址值，如果返回false则说明是多例（容器中存在多个对象），否则则是单例

@Test
public void test2(){
    ApplicationContext app = new ClassPathXmlApplicationContext("applicetionContext.xml");
    UserDao userDao1 = (UserDao) app.getBean("userDao");
    UserDao userDao2 = (UserDao) app.getBean("userDao");
    System.out.println(userDao1.equals(userDao2));
}

打印结果:

结论：是多例

由于其他三种需要在WEB环境下进行演示，这里就不一一演示了

测试两个属性的对象创建时期

1️⃣singleton

由于Spring创建对象是通过无参构造进行创建对象，因此我们可以在实现类中提供无参构造器，并打印一句话，如果创建对象时成功输出该语句，则说明无参构造方法被调用了，同时也说明该对象被创建了一次

1、设置参数

2、在实现类中提供无参构造

public class UserDaoImpl implements UserDao {

    public UserDaoImpl() {
        System.out.println("UserDaoImpl创建。。。");
    }

    @Override
    public void save() {
        System.out.println("do save......");
    }
}

3、编写测试类

@Test
public void test3(){
    ApplicationContext app = new ClassPathXmlApplicationContext("applicetionContext.xml");
    UserDao userDao = (UserDao) app.getBean("userDao");
    userDao.save();

}

启动debug测试：

打印结果：

结论：创建容器并配置文件一旦被加载，UserDao对象则被创建

2️⃣

1、设置参数

2、在实现类中提供无参构造

public class UserDaoImpl implements UserDao {

    public UserDaoImpl() {
        System.out.println("UserDaoImpl创建。。。");
    }

    @Override
    public void save() {
        System.out.println("do save......");
    }
}

3、编写测试类

    public void test3(){
        ApplicationContext app = new ClassPathXmlApplicationContext("applicetionContext.xml");
        UserDao userDao1 = (UserDao) app.getBean("userDao");
        UserDao userDao2 = (UserDao) app.getBean("userDao");

        System.out.println(userDao1);
        System.out.println(userDao2);

    }


}

启动debug测试：

可以看出，参数为prototype时，是在getBean时创建对象的

总结：

1️⃣当scope的取值为singleton时

Bean的实例化个数：1个

Bean的实例化时机：当Spring核心文件被加载时，实例化配置的Bean实例

Bean的生命周期：

对象创建：当应用加载，创建容器时，对象就被创建了
对象运行：只要容器在，对象一直活着
对象销毁：当应用卸载，销毁容器时，对象就被销毁了

2️⃣当scope的取值为prototype时

Bean的实例化个数：多个

Bean的实例化时机：当调用getBean()方法时实例化Bean

对象创建：当使用对象时，创建新的对象实例
对象运行：只要对象在使用中，就一直活着
对象销毁：当对象长时间不用时，被 Java 的垃圾回收器回收了

Bean生命周期配置

init-method:指定类中的初始化方法名称
destory-method:指定类中销毁方法名称

测试：

在实现类中创建两个方法，一个是代表对象创建完毕的初始化方法，一个代表这个对象销毁之前的销毁方法

public class UserDaoImpl implements UserDao {

    public UserDaoImpl() {
        System.out.println("UserDaoImpl创建。。。");
    }

    public void init(){
        System.out.println("初始化方法。。。");
    }


    public void destroy(){
        System.out.println("销毁方法方法。。。");
    }

    @Override
    public void save() {
        System.out.println("do save......");
    }
}

没有在配置文件中指明方法时，init方法和destroy方法是不会被调用的

在配置文件中指明方法

测试类：

    @Test
    public void test3(){
        ClassPathXmlApplicationContext app = new ClassPathXmlApplicationContext("applicetionContext.xml");
        UserDao userDao1 = (UserDao) app.getBean("userDao");
        System.out.println(userDao1);
        app.close();
    }
}

打印结果：

因为是单元测试，并没有在服务器内执行，还没来得及打印销毁方法，方法就执行完毕了。所以我们需要让容器手动关闭，容器在自动关闭前会执行一些方法，但 ApplicationContext没有close方法，所以这里使用ClassPathXmlApplicationContext 。

Bean实例化的三种方式

无参构造方法实例化（重点）
工厂静态方法实例化
工厂实例方法实例化

工厂静态方法实例化

1、创建静态工厂

public class staticFactory {
    public static UserDao getUserDao(){
        return new UserDaoImpl();
    }

}

2、在配置文件中说明，通知Spring是通过静态工厂创建

3、测试

    @Test
    public void test3(){
        ClassPathXmlApplicationContext app = new ClassPathXmlApplicationContext("applicetionContext.xml");
        UserDao userDao1 = (UserDao) app.getBean("userDao");
        System.out.println(userDao1);
        //app.close();
    }
}

打印结果：

工厂实例方法实例化

1、此时该方法不再是静态，

public class DynamicFactory {
    public  UserDao getUserDao(){
        return new UserDaoImpl();
    }
}

2、在配置文件中说明，通知Spring是通过实例工厂创建（由于是非静态，所以需要先有工厂对象，才能调用方法）

3、测试

    public void test3(){
        ClassPathXmlApplicationContext app = new ClassPathXmlApplicationContext("applicetionContext.xml");
        UserDao userDao1 = (UserDao) app.getBean("userDao");
        System.out.println(userDao1);
        //app.close();
    }
}

测试结果：

Spring配置文件-依赖注入

模拟web环境下的三层结构

1、创建业务层代码

public interface UserService {
    public void save();
}

//**********************
public class UserServiceImpl implements UserService {
    @Override
    public void save() {
        ClassPathXmlApplicationContext app = new ClassPathXmlApplicationContext("applicetionContext.xml");
        UserDao userDao = (UserDao) app.getBean("userDao");
        userDao.save();
    }

3、模拟web（由于Spring没有获取到userService对象，这里需要我们进行手动创建）

public class UserController {
    public static void main(String[] args) {
        UserService userService = new UserServiceImpl();
        userService.save();
    }
}

测试结果：

3.+：我们可以通过配置文件配置并获取userService对象

模拟web层

public class UserController {
    public static void main(String[] args) {
        ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserService userService =(UserService) app.getBean("userService");
        userService.save();

    }
}

测试结果：

上面的代码是存在问题的

因为UserService和UserDao都在Spring容器中，而最终程序直接使用的是UserService,所以可以在Spring容器中，将UserDao设置到UserService内部

我们可以通过有参构造把数据注入到对象内部

依赖注入

依赖注入（Dependency Injection）：它是 Spring 框架核心 IOC 的具体实现。

在编写程序时，通过控制反转，把对象的创建交给了 Spring，但是代码中不可能出现没有依赖的情况。

IOC 解耦只是降低他们的依赖关系，但不会消除。例如：业务层仍会调用持久层的方法。

那这种业务层和持久层的依赖关系，在使用 Spring 之后，就让 Spring 来维护了。

简单的说，就是坐等框架把持久层对象传入业务层，而不用我们自己去获取

Bean的依赖注入方式

构造方法
set方法

①set方法

1、在UserServiceImpl内提供set方法

public class UserServiceImpl implements UserService {
   private UserDao userDao;

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

    @Override
    public void save() {
        userDao.save();
    }
}

2、在配置文件中进行配置，告诉Spring把UserDao注入给UserServiceImpl

测试：

public class UserController {
    public static void main(String[] args) {
        ApplicationContext app = new ClassPathXmlApplicationContext("applicetionContext.xml");
        UserService userService =(UserService) app.getBean("userService");
        userService.save();

    }
}

测试结果：

简便注入（P命名空间注入）：

②构造方法

1、在UserServiceImpl内提供构造器

public class UserServiceImpl implements UserService {
   private UserDao userDao;

    public UserServiceImpl(UserDao userDao) {
        this.userDao = userDao;
    }
    public UserServiceImpl(){}

    @Override
    public void save() {
        userDao.save();
    }
}

2、配置Spring容器调用有参构造时进行注入

3、测试

public class UserController {
    public static void main(String[] args) {
        ApplicationContext app = new ClassPathXmlApplicationContext("applicetionContext.xml");
        UserService userService =(UserService) app.getBean("userService");
        userService.save();

    }
}

测试结果：

依赖注入的数据类型

上面的操作，都是注入的引用Bean，处了对象的引用可以注入，普通数据类型，集合等都可以在容器中进行注入。

注入数据的三种数据类型

普通数据类型
引用数据类型
集合数据类型

其中引用数据类型，此处就不再赘述了，之前的操作都是对UserDao对象的引用进行注入的，下面将以set方法注入为例，演示普通数据类型和集合数据类型的注入。

测试普通数据类型（set方法）

1、在UserDaoImpl中提供set方法

public class UserDaoImpl implements UserDao {
    private String username;
    private int age;

    public void setUsername(String username) {
        this.username = username;
    }

    public void setAge(int age) {
        this.age = age;
    }
    
        @Override
    public void save() {
        System.out.println(username+"======"+age);
        System.out.println("do save......");
    }
}

2、在配置文件中进行配置

测试：

public class UserController {
    public static void main(String[] args) {
        ApplicationContext app = new ClassPathXmlApplicationContext("applicetionContext.xml");
        UserService userService =(UserService) app.getBean("userService");
        userService.save();

    }
}

测试结果：

测试集合数据类型（set方法）

1、在UserDaoImpl中提供集合属性并提供set方法

public class UserDaoImpl implements UserDao {
    private String username;
    private int age;
    private List strList;
    private Map userMap;
    private Properties properties;

    public void setStrList(List strList) {
        this.strList = strList;
    }

    public void setUserMap(Map userMap) {
        this.userMap = userMap;
    }

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

    public void setUsername(String username) {
        this.username = username;
    }

    public void setAge(int age) {
        this.age = age;
    }


    @Override
    public void save() {
        System.out.println(username+"======"+age);
        System.out.println("strList："+strList);
        System.out.println("userMap:"+userMap);
        System.out.println("properties:"+properties);
        System.out.println("do save......");
    }
}

2、在配置文件中进行配置

测试类

public class UserController {
    public static void main(String[] args) {
        ApplicationContext app = new ClassPathXmlApplicationContext("applicetionContext.xml");
        UserService userService =(UserService) app.getBean("userService");
        userService.save();

    }
}

测试结果

引入其他配置文件（分模块开发）

实际开发中，Spring的配置内容非常多，这就导致Spring配置很繁杂且体积很大，所以，可以将部分配置拆解到其他配置文件中，而在Spring主配置文件通过import标签进行加载

可以根据层分，也可以根据功能去拆

Spring的重点配置

Spring相关API

ApplicationContext的继承体系

三个实现类

getBean的方法

其中，当参数的数据类型是字符串时，表示根据Bean的id从容器中获得Bean实例，返回是Object，需要强转。

当参数的数据类型是Class类型时，表示根据类型从容器中匹配Bean实例，当容器中相同类型的Bean有多个时，则此方法会报错

ApplicationContext applicationContext = new 
            ClassPathXmlApplicationContext("applicationContext.xml");
  UserService userService1 = (UserService) applicationContext.getBean("userService");
  UserService userService2 = applicationContext.getBean(UserService.class);

Spring实战学习01----------之认识Bean

Java相关栏目本月热门文章