Spring入门（Spring程序开发步骤）

目录

1、Spring程序开发步骤

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

1.2、编写Dao接口和实现类

1.3、创建Spring核心配置文件

1.4、测试程序

2、Bean标签范围配置

2.1、scope属性

2.2、Bean实例化时机 

2.3、Bean生命周期配置

2.4、实例化Bean的三种方式

---

前言：本次整理内容为黑马视频课程，进行笔记整理。 

1、Spring程序开发步骤

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

2、编写Dao接口和实现类。

3、创建Spring核心配置文件。

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

首先我们需要创建一个Maven工程，在pom文件中导入Spring的坐标

pom文件

<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0modelVersion>
 
    <groupId>cn.itsslgroupId>
    <artifactId>spring_01artifactId>
    <version>1.0-SNAPSHOTversion>
 
    <dependencies>
        <dependency>
            <groupId>org.springframeworkgroupId>
            <artifactId>spring-contextartifactId>
            <version>5.3.2version>
        dependency>
        <dependency>
            <groupId>junitgroupId>
            <artifactId>junitartifactId>
            <version>4.10version>
        dependency>
    dependencies>
 
project>

1.2、编写Dao接口和实现类

在包路径下创建dao层和实现类，并编写一个方法show()用来测试

UserDao接口

public interface UserDao {
    void show();
}

UserDaoImpl类

public class UserDaoImpl implements UserDao {
    //重写show()方法
    public void show() {
        System.out.println("show running....");
    }
    //无参构造
    UserDaoImpl(){
        System.out.println("无参构造...");
    }
    
}

1.3、创建Spring核心配置文件

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

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

在resources文件中创建一个xml文件，命名为ApplicationContext（推荐命名，可以自定义）

<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="UserDao" class="cn.itssl.dao.Impl.UserDaoImpl">bean>
beans>

标签中的属性介绍： 

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

class：Bean的全限定名称。 

注意：这里的bean标签里id名可以随意起，这里是为了方便测试直接起成UserDao，class里填写的就是UserDaoImpl的路径，为了避免书写错误，可以右键UserDaoImpl点击Copy Reference，直接粘贴过去。

1.4、测试程序

我们在测试包下创建一个测试类，用来测试。

 

利用多态进行创建ApplicationContext对象，ClassPathXmlApplicationContext中填入xml配置文件。获取到app对象，通过app的方法getBean方法创建UserDao对象。 

public class userDaoTest {
    public static void main(String[] args) {
        ApplicationContext app=new ClassPathXmlApplicationContext("ApplicationContext.xml");
        UserDao userDao = (UserDao) app.getBean("UserDao");
        System.out.println(userDao); 
    }
}

2、Bean标签范围配置

2.1、scope属性

在实际开发中，可能需要用到的对象有不同的模式，其中就有单例模式和多例模式，在之前我们都是通过工厂创建单例或者多例，那么在Spring中如何控制单例和多例呢？

在bean标签中，有一个属性可以控制scope，有两个关键词，一个为singleton（单例）、prototype（多例）。

scope属性中关键词：

单例模式演示

<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="UserDao" class="cn.itssl.dao.Impl.UserDaoImpl" scope="singleton">bean> 

 测试类我们通过getBean获取两个userDao对象，看看地址值是否一样

public class userDaoTest {
    public static void main(String[] args) {
        ApplicationContext app=new ClassPathXmlApplicationContext("ApplicationContext.xml");
        UserDao userDao1 = (UserDao) app.getBean("UserDao");
        UserDao userDao2 = (UserDao) app.getBean("UserDao");
        System.out.println(userDao1);
        System.out.println(userDao2);
    }
}

可以看出，地址值是一模一样的，说明这就是单例模式。

多例模式演示

<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="UserDao" class="cn.itssl.dao.Impl.UserDaoImpl" scope="prototype">bean> 

可以发现这次的地址值不一样了，那么说明就是多例模式了。

2.2、Bean实例化时机 

1、当scope的取值为singleton时

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

Bean的生命周期：

对象创建：当应用加载，创建容器时，对象就被创建了。

对象运行：只要容器在，对象一直活着。

对象销毁：当应用卸载，销毁容器时，对象就销毁了。

2、当scope的取值为prototype时

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

对象创建：当使用对象时，创建新的对象实例。

对象运行：只要对象在使用中，就会一直活着。

对象销毁：当对象长时间不用时，被Java的垃圾回收器回收了。

2.3、Bean生命周期配置

为了方便看到bean何时被创建，何时被销毁，我们在实现类中写两个方法，分别是initialization方法和destroy方法，这两个方法命名随意。

userDaoImpl实现类

    public void show() {
        System.out.println("show running....");
    }
    public UserDaoImpl(){
        System.out.println("无参构造...");
    }
    //初始化方法
    public void initialization(){
        System.out.println("初始化...");
    }
    //销毁方法
    public void destroy(){
        System.out.println("销毁");
    }

 那么如何让这两个方法生效呢，就用bean去管理它，配置xml中bean标签中的属性init-method（初始化方法）和destory-method（销毁方法）。属性中填写的就是你写的方法名

ApplicationContext.xml配置文件

<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="userDao" class="cn.itssl.dao.Impl.UserDaoImpl" init-method="initialization" destroy-method="destroy">bean>
beans>

测试类 

public class userDaoTest2 {
    public static void main(String[] args) {
        ApplicationContext app=new ClassPathXmlApplicationContext("ApplicationContext.xml");
        UserDao userDao = (UserDao) app.getBean("userDao");
        System.out.println(userDao);
    }
}

可以看到无参构造先被执行，然后运行初始化方法，最后输出对象。那么销毁方法怎么没有输出呢？因为 ApplicationContext没有close方法，而它的子类ClassPathXmlApplicationContext有close关闭方法，所以我们需要手动去关闭bean，我们直接创建ApplicationContext的子类对象，最后调用ClassPathApplication的close方法。

public class userDaoTest2 {
    public static void main(String[] args) {
        ClassPathXmlApplicationContext app=new ClassPathXmlApplicationContext("ApplicationContext.xml");
        UserDao userDao = (UserDao) app.getBean("userDao");
        System.out.println(userDao);
        app.close();
    }
}

 

 可以看到最后执行了销毁方法。

2.4、实例化Bean的三种方式

1、无参构造方法实例化（上面代码已演示）

2、工厂静态方法实例化

3、工厂实例方法实例化

工厂静态方法实例化

我们需要再创建一个包为factory的工厂包，用来存放工厂类

创建StaticFactory类 

public class StaticFactory {
    //静态方法
    public static UserDao getUserDao(){
        //返回userDao的实现类对象
        return new UserDaoImpl();
    }
}

配置ApplicationContext.xml文件

class路径选择工厂类，然后添加属性factory-method，书写静态实例化方法名，因为静态方法是属于类的，所以可以写工厂类路径，通过factory-method获取方法。

<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="userDao" class="cn.itssl.factory.StaticFactory" factory-method="getUserDao">bean>
beans>

测试类

public class userDaoTest3 {
    public static void main(String[] args) {
        ApplicationContext app=new ClassPathXmlApplicationContext("ApplicationContext1.xml");
        UserDao userDao = (UserDao) app.getBean("userDao");
        System.out.println(userDao);
    }
}

工厂静态实例化成功运行！

工厂实例方法实例化

我们再在factory包下创建一个DynamicFactory类

DynamicFactory类

public class DynamicFactory {
    //非静态方法
    public UserDao getUserDao() {
        return new UserDaoImpl();
    }
}

ApplicationContext.xml配置文件 

因为getUserDao现在不属于类了，所以我们需要先配置一个bean来获取工厂类对象，class里书写的是DynamicFactory类的路径，然后再创建一个bean使用factory-bean来接收工厂类对象factory，然后通过factory-method属性获取getUserDao方法，这里可能会有点绕，反复理解一下，静态是属于类，非静态是不属于类，所以非静态需要多做一步操作，就是用一个bean先去创建类对象，再由另一个bean去接收。

<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="factory" class="cn.itssl.factory.DynamicFactory">bean>
    <bean id="userDao" factory-bean="factory" factory-method="getUserDao">bean>
 
beans>

测试类

public class userDaoTest4 {
    public static void main(String[] args) {
        ApplicationContext app=new ClassPathXmlApplicationContext("ApplicationContext2.xml");
        UserDao userDao = (UserDao) app.getBean("userDao");
        System.out.println(userDao);
    }
}

​​​​​​​