zoukankan html css js c++ java

3. Spring配置文件

Spring配置文件

【对第一个 HelloWorld 程序】进行解刨知识点

1.Bean标签基本配置

用于配置对象交由Spring 来创建。默认情况下它调用的是类中的无参构造函数，如果没有无参构造函数则不能创建成功。【这种方法叫做无参方法实例化 Bean对象是根据它的无参构造来获取的】

基本属性： id：Bean实例在Spring容器中的唯一标识【emm 唯一标识真是个常识.】

class：Bean的全限定名称　　【记得带包名而且方法要有无参构造】

2.Bean标签范围配置

除了 Id 和 Class ，Bean标签还有一个属性 scope ：学过JSP都知道是域、范围的意思.

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

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

所以我们没配置他就会 singleton 单的，我们先详说 singletion 和 prototype :

因为其他设计到了 WEB 项目：

Bean标签范围配置

1）当scope的取值为singleton时 Bean的实例化个数：1个　　【无参构造只执行一次】

Bean的实例化时机：当Spring核心文件被加载时，实例化配置的Bean实例　　【意思是说 emmmm 在获取到XML对象时只执行一次无参构造那么证明只实例化一次以后都是同一对象而且只有一个Bean对象因为是singleton 单例】

Bean的生命周期：对象创建：当应用加载，创建容器时，对象就被创建了　　【出生】

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

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

2）当scope的取值为prototype时 Bean的实例化个数：多个　　【实例化一个就执行一次无参构造】

Bean的实例化时机：当调用getBean()方法时实例化Bean　　　　　　　　【意思是说 emmmm 在获取到XML对象时不会实例化当 getBean 时会执行无参构造一次每一次都是不同的对象不同的Bean】

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

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

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

例：【Junit 测试：】

HelloServer.java : 【接口】

package com.bihu.helloDao;

public interface HelloService {
    void show();
}

HelloServiceImpl.java :　　【实现类】

package com.bihu.helloImpl;

import com.bihu.helloDao.HelloService;

public class HelloServiceImpl implements HelloService {

    //无参构造：


    public HelloServiceImpl() {
        System.out.println("实例化了一个 HelloServiceImpl 对象 执行了无参构造");
    }

    public void show() {
        System.out.println("Hello World!");
    }
}

applicationContext.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">
<!--  默认 singleton【单例】 自行更换 prototype【多例】   -->
    <bean id="hello_bean" class="com.bihu.helloImpl.HelloServiceImpl" scope="singleton" ></bean>
</beans>

Test：　　【一般测试类都新建一个文件夹 Test 然后里面包都和 main 的差不多其实就是一个 java 一个 resource 】

import com.bihu.helloImpl.HelloServiceImpl;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class test {

    @Test //要导入 Junit 的 GAV
    public void springTest(){
        //获取XML
        ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");
        //实例化两个 HelloServiceImpl 对象：
         HelloServiceImpl app1  = (HelloServiceImpl)app.getBean("hello_bean");
         HelloServiceImpl app2  = (HelloServiceImpl)app.getBean("hello_bean");

         //分别打印他的地址 如果在你spring配置文件中的Bean 是singleton 的话 地址会一样，如果是prototype的话 会不一样 其次执行的无参构造次数也不一样
        // 所以可以根据它的特性来DEBUG：
        System.out.println(app1);
        System.out.println(app2);

    }


}

所以单例和多例的区别就在这里自己测试即可.

3. Bean生命周期配置

init-method：指定类中的初始化方法名称

destroy-method：指定类中销毁方法名称

直接在 Bean 中配即可，但是确保 Bean中有函数存在，例：

当然名字你自己设置啊自定义.

HelloServiceImpl.java

package com.bihu.helloImpl;

import com.bihu.helloDao.HelloService;

public class HelloServiceImpl implements HelloService {

    //无参构造：


    public HelloServiceImpl() {
        System.out.println("实例化了一个 HelloServiceImpl 对象 执行了无参构造");
    }

    public void show() {
        System.out.println("Hello World!");
    }


    /*--初始化 和 销毁 方法： --*/
    public void init() {
        System.out.println("Bean出生了");
    }

    public void destroy() {
        System.out.println("Bean销毁了");
    }

}

Spring配置文件：

<?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">
<!--  默认 singleton【单例】 自行更换 prototype【多例】   -->
    <bean id="hello_bean" class="com.bihu.helloImpl.HelloServiceImpl" scope="singleton" init-method="init" destroy-method="destroy" ></bean>
</beans>

测试：当你单单获取xml 的话他会执行 init方法因为在spring中设置了

import com.bihu.helloImpl.HelloServiceImpl;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class test {

    @Test //要导入 Junit 的 GAV
    public void springTest(){
        ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");
    }
}

它的输出：

信息: Loading XML bean definitions from class path resource [applicationContext.xml]
实例化了一个 HelloServiceImpl 对象 执行了无参构造
Bean出生了

Process finished with exit code 0

但是没执行销毁方法因为 emmmm 没来得及打印....

如果你实在想去测试，那么：

import com.bihu.helloImpl.HelloServiceImpl;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class test {

    @Test //要导入 Junit 的 GAV
    public void springTest(){
        //ApplicationContext 改成了 ClassPathXmlApplicationContext，因为ClassPathXmlApplicationContext是ApplicationContext的实现类，所以有close方法.
        ClassPathXmlApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");
        app.close();    //关掉 所以就可以自动调用 销毁方法了

        //这个理解即可 知道那个原理
    }
}

输出：

信息: Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@574caa3f: startup date [Fri Jun 18 11:57:00 CST 2021]; root of context hierarchy
六月 18, 2021 11:57:00 上午 org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions
信息: Loading XML bean definitions from class path resource [applicationContext.xml]
实例化了一个 HelloServiceImpl 对象 执行了无参构造
Bean出生了
六月 18, 2021 11:57:00 上午 org.springframework.context.support.AbstractApplicationContext doClose
信息: Closing org.springframework.context.support.ClassPathXmlApplicationContext@574caa3f: startup date [Fri Jun 18 11:57:00 CST 2021]; root of context hierarchy
Bean销毁了

4.Bean实例化三种方式

1.无参构造方法实例化

2.工厂静态方法实例化

3.工厂实例方法实例化

第一种不多说上面那个就是无参构造方法实例化

工厂静态方法实例化：

说到工厂就想起 factory ，就想到工厂模式，而且是静态的：

其实就是返回一个指定的对象回去（工厂）　，然后在Spring配置文件中配置【Class变为工厂模式的地址、添加 factory-method 字段，值是工厂类的方法【返回对象那个方法】】

其实就是反射，接下来看代码：

先创建一个静态工厂　　这里是 StaticFactroy类：

package com.bihu.factroy;

import com.bihu.helloImpl.HelloServiceImpl;

//静态工厂
public class StaticFactroy {
    public static HelloServiceImpl GetHelloServiceImpl(){
        return new HelloServiceImpl();
    }
}

然后我们配置Spring文件：

<?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="StaticFactory" class="com.bihu.factroy.StaticFactroy" factory-method="GetHelloServiceImpl"></bean>

</beans>

记住静态工厂实例化模式是factory-method 一个就够！！！

然后我们测试：Test.java:

<?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="StaticFactory" class="com.bihu.factroy.StaticFactroy" factory-method="GetHelloServiceImpl"></bean>

</beans>

输出：

信息: Loading XML bean definitions from class path resource [applicationContext.xml]
实例化了一个 HelloServiceImpl 对象 执行了无参构造
Hello World!

Process finished with exit code 0

证明是毫无问题的这种。

工厂实例方法实例化

刚刚是静态的这次来个不是静态的：

想想看既然是工厂实例方法少不了创建工厂模式，但是由于不是静态的话肯定要先获取到他的工厂实例然后配置哪方面：肯定要先有工厂Bean 那么就是先创建一个工厂Bean 然后跟着这个工厂Bean进去找方法即可完成实例化 Bean.

其中在Spring的配置文件中获取工厂Bean 是：factory-bean 属性，值是自己配的工厂Bean，所以工厂Bean 相当于Class 。

所以大体思路唯一要改的就是 Spring的配置文件和去掉静态方法上代码：

package com.bihu.factroy;

import com.bihu.helloImpl.HelloServiceImpl;

//工厂模式实例化
public class StaticFactroy {
    public HelloServiceImpl GetHelloServiceImpl(){
        return new HelloServiceImpl();
    }
}

去掉静态的啊因为是工厂实例方法实例化...有点绕口..

然后是Spring 配置文件：

<?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">
<!--工厂实例化：-->
<!--  因为不是静态的 所以先创建一个FactoryBean，在通过FactoryBean去反射找到指定的方法 实例化   Bean  -->

<!-- 先获取工厂Bean:   -->
    <bean id="FactoryBean" class="com.bihu.factroy.StaticFactroy"></bean>

<!-- 然后根据工厂Bean获取指定方法获取Bean   -->
    <bean id="Bean" factory-bean="FactoryBean" factory-method="GetHelloServiceImpl" ></bean>
</beans>

其实这里的 FactoryBean 相当于静态工厂模式的 Class .

说那么多已经是很保姆级别的了请带脑子阅读...

测试： Test.java ：

import com.bihu.helloImpl.HelloServiceImpl;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class test {

    @Test //要导入 Junit 的 GAV
    public void springTest(){
        ClassPathXmlApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");
        HelloServiceImpl staticFactory = (HelloServiceImpl)app.getBean("Bean");
        staticFactory.show();
    }
}

Bean 差不多了... 主要还是要有反射思维...

注意：不要看这里的包名我乱打的！！！和MVC模式对不上的！不是MVC模式！！！你只需知道一个接口一个实现即可,因为是测试所以没认真看包名.你只需要知道那个是接口那个是实现即可，真正的MVC模式命名和归类是很规范的.

完.

本文来自博客园，作者：咸瑜，转载请注明原文链接：https://www.cnblogs.com/bi-hu/p/14898630.html

查看全文

相关阅读:
函数
 A × B problem
求n的阶乘
 自己构建一个vector函数
 int与string的互相转化
 列一列（斐波那契数列）
找一找
 c++大数计算模板
 JSON--js中 json字符串转对象、对象转字符串
 JSON

原文地址：https://www.cnblogs.com/bi-hu/p/14898630.html

热门文章
04 树莓派更换镜像源
 作业13
作业12
闭包函数
 python错误Fatal error in launcher
名称空间与作用域
 作业11
作业10
作业9+
作业9