Bean属性继承

应用场景：

场景一：ParentClass（属性1,属性2，属性3，get和set方法）

子类1（属性4，属性5） 

子类2（属性6，属性7）

场景2：子类1和子类2没有父类，而是有一些相同的属性。

类1：（属性1，属性2，属性3，属性4，属性5）

类2：（属性1，属性2，属性3，属性6，属性7）

这两个场景下，通过Spring注入类1和类2的所有属性，一般如下：

abstract="true"：设置<bean>标签只是定义性的，不会对它进行实例化操作。

parent属性：在Bean的子类bean标签添加，值为父类的Id。

Spring配置代码：

  <!-- 如果Class1和Class2属性1、2、3相同 -->

步骤1： <bean id="bean" class="main.java.com.Bean继承属性.ParentClass" abstract="true">

             <property name="attribute1" value="attribute1"></property>

             <property name="attribute2" value="attribute2"></property> 

             <property name="attribute3" value="attribute3"></property>

             </bean>

 步骤2：    <bean id="bean1" class="main.java.com.Bean继承属性.Class1" parent="bean">

                 <property name="attribute4" value="attribute4"></property>

                 <property name="attribute5" value="attribute5"></property>

                 </bean>   

<bean id="bean2" class="main.java.com.Bean继承属性.Class2" parent="bean">

        <property name="attribute6" value="attribute6"></property>

        <property name="attribute7" value="attribute7"></property>

        </bean>

测试：

@Test

public void test(){

ApplicationContext ac=new ClassPathXmlApplicationContext("spring-extends.xml");

Class1 c1=ac.getBean("bean1", Class1.class);

Class2 c2=ac.getBean("bean2",Class2.class);

System.out.println(c1);

System.out.println(c2);

}

结果：

Class1 [attribute1=attribute1, attribute2=attribute2, attribute3=attribute3, attribute4=attribute4, attribute5=attribute5]

Class1 [attribute1=attribute1, attribute2=attribute2, attribute3=attribute3, attribute6=attribute6, attribute7=attribute7]

应用场景2：类1和类2不继承某一父类，只是存在相同属性。

spring配置：

 <!-- 如果Class1和Class2属性1、2、3相同 -->

     步骤1：   <bean id="bean" abstract="true">

         <property name="attribute1" value="attribute1"></property>

        <property name="attribute2" value="attribute2"></property> 

        <property name="attribute3" value="attribute3"></property>

        </bean>

      步骤2：  <bean id="bean1" class="main.java.com.Bean继承属性.Class1" parent="bean">

        <property name="attribute4" value="attribute4"></property>

        <property name="attribute5" value="attribute5"></property>

        </bean>   

        <bean id="bean2" class="main.java.com.Bean继承属性.Class2" parent="bean">

        <property name="attribute6" value="attribute6"></property>

        <property name="attribute7" value="attribute7"></property>

        </bean>        

Bean初始化及销毁逻辑处理（在singleton作用域上进行讲解）

Bean初始化——如果需要在Bean实例化时执行一些逻辑，Spring提供了两种方法：（有一个javaBean，该Bean作用，连接数据库，例如session，断开数据库连接，该Bean被创建之后，执行数据库连接的过程）

方法1：bean标签里的init-method属性，该值为Bean的某一方法，Spring实例化时，会调用Bean的该方法。

方法2：让Bean实现InitializingBean接口，Spring在实例化该Bean时，检测到Bean实现了该接口，就会调用该接口所定义的相应方法。

Bean销毁——如果需要在Bean销毁之前执行一些逻辑，有两种方法。

方法1：bean标签里的destory-method属性，该值为Bean的某一方法，Spring销毁该Bean时，会调用Bean的该方法。

方法2：让Bean实现DisposableBean接口，Spring在销毁该Bean时，检测到Bean实现了该接口，就会调用该接口所定义的相应方法。

案例1：通过bean标签的init-method和destory-method属性来指定Bean初始化逻辑和销毁逻辑。

代码：

public class Bean {

public void onInit(){

System.out.println("Bean的初始化逻辑方法被执行了");

}

public void onDestory(){

System.out.println("Bean的销毁逻辑方法被执行了");

}

}

测试代码：

@Test

public void test(){

ApplicationContext ac=new ClassPathXmlApplicationContext("spring-initAnddestory.xml");

Bean bean=ac.getBean("bean", Bean.class);

System.out.println(bean);

}

结果：bean的销毁方法没执行，因为当前是单例模式，所以Bean的初始化是在Spring上下文实例化完成的，Bean的销毁是在Spring上下文的销毁过程中执行Bean的销毁。（Spring上下文的销毁定义到AbstractApplicationContext中）

Bean的初始化逻辑方法被执行了

main.java.com.Bean初始化及销毁.Bean@b8a1063

spring配置：

<bean class="main.java.com.Bean初始化及销毁.Bean" id="bean" init-method="onInit" destroy-method="onDestory">

改进：

@Test

public void test(){

AbstractApplicationContext ac=new ClassPathXmlApplicationContext("spring-initAnddestory.xml");

Bean bean=ac.getBean("bean", Bean.class);

System.out.println(bean);

ac.close();

}

注意：如果所有的Bean都有相同名称的初始化方法和相同名称的销毁方法，可以在<beans default-init-method="onInit"   default-destory-method="onDestory">,含义：所有的bean都有初始化方法和销毁方法。

案例2：实现相应接口，并实现相应方法

代码：

public class Bean implements InitializingBean,DisposableBean{

@Override

public void destroy() throws Exception {

System.out.println("Bean的销毁逻辑方法被执行了");

}

@Override

public void afterPropertiesSet() throws Exception {

System.out.println("Bean的初始化逻辑方法被执行了");

}

}

spring配置：

<bean class="main.java.com.Bean初始化及销毁.Bean" id="bean"></bean>

测试：

@Test

public void test(){

AbstractApplicationContext ac=new ClassPathXmlApplicationContext("spring-initAnddestory.xml");

Bean bean=ac.getBean("bean", Bean.class);

System.out.println(bean);

ac.close();

}

Bean的懒加载

测试：

@Test

public void test(){

ApplicationContext ac=new ClassPathXmlApplicationContext("spring_lanjiazai.xml");

System.out.println("context被创建了");

Bean bean=ac.getBean("bean", Bean.class);

System.out.println(bean);

结果：

Bean被创建了

context被创建了

main.java.com.Bean懒加载.Bean@b8a1063

证明：当Spring上下文初始化时，作用域为singleton的Bean就已经被创建好了，而不是通过Spring上下文获取时才去创建。

Bean懒加载概念：

Spring容器会在创建容器时提前初始化Singleton作用域的bean，但是如果Bean被标注了lazy-init=“true”,则该Bean只有在其被需要的时候才会被初始化。（只对singleton作用域的bean有效）

代码：

<bean id="bean" class="main.java.com.Bean懒加载.Bean" scope="singleton" lazy-init="true"></bean>

解决多个bean使用懒加载问题：

<beans标签里添加default-lazy-init=“true”>:表示spring配置文件里所有bean都是懒加载模式。

使用场景：

如果某个Bean在程序整个运行周期都可能不会被使用，那么可考虑设定该Bean为懒加载。

优点：尽可能的节省了资源。

缺点：可能会导致某个操作相应操作时间增加。

scope 的web 作用域

代码回顾

javabean 的作用域是request 每次请求都会创建一个新的实例

                               session  在一次回话中都是同一个实例，重开浏览器会有不同的实例

                               appliction 是同一个服务内都是同一个实例，重启服务会产生不同的实例

三个类对应的配置文件

application session  request  三个测试类

spring web 上下文环境配置

springweb 上下文环境

课程内容：注入bean的课程内容

spring通过xml实现自定义作用域（自定义双例模式作用域）

SimpleThreadScope：Spring内置作用域。

编写自定义作用域：

步骤1：实现Scope接口(org.springframework.beans.factory.config),主要关注实现的get方法和remove方法。

get方法：按照name参数，按照我们自己定义的规则，去返回一个Bean，如果我们定义的规则里，Bean不存在，那么将通过objectFactory去创建一个Bean。

双例模式：一个bean的Id对应两个实例，实现双例模式，需要两个Map集合，Map<String,Object> map1=new HashMap<String,Object>();Map<String,Object> map2=new HashMap<String,Object>();。

get方法：

public Object get(String name, ObjectFactory<?> objectFactory) {

if(!map1.containsKey(name)){   //判断map1是否包含名为name的Bean实例

Object o=objectFactory.getObject();//如果不存在则创建一个ObjectFactory规则Bean

map1.put(name, o);   //并把这个Bean放入集合,并命名为name

return o;

}

if(!map2.containsKey(name)){   //map2同map1操作

Object o=objectFactory.getObject(); 

map2.put(name, o);  

return o;

}

//如果map1和map2都包含这个Bean,也就是说Spring上下文通过Id获取有两个实例,则返回一个0或1

int i=new Random().nextInt(2);

if(i==0){

return map1.get(name);//如果是0,则返回对象1

}else{

return map2.get(name);//如果是0,则返回对象2

}

}

remove方法：和get方法相反，按照name参数，去移除一个Bean。

public Object remove(String name) {

if(map1.containsKey(name)){

Object o=map1.get(name);

map1.remove(name);

return o;

}

if(map2.containsKey(name)){

Object o=map2.get(name);

map2.remove(name);

return o;

}

return null;    //说明没拿到任何实例

}

xml配置：

<bean id="myScope" class="main.java.com.自定义作用域.MyScope"  >

</bean>

<bean  class="org.springframework.beans.factory.config.CustomScopeConfigurer">

<property name="scopes">

<map>

<entry key="myscope" value-ref="myScope"></entry>

</map>

</property>

</bean>

测试代码：

@Test

public void testBean(){

ApplicationContext ac=new ClassPathXmlApplicationContext("spring-zidingyi.xml");

for(int i=0;i<10;i++){

Bean bean=ac.getBean(“myScope”", Bean.class);

System.out.println(bean);

}

}

Spring提供的另外一个作用域：SimpleThreadScope(同一线程，Spring上下文会分配同一实例，不同线程，则获得不同实例。

srping配置：

<bean id="myScope" class="main.java.com.自定义作用域.MyScope" ></bean>

<bean id="simpleThreadScope" class="org.springframework.context.support.SimpleThreadScope"></bean>

<bean class="org.springframework.beans.factory.config.CustomScopeConfigurer">

<property name="scopes">

<map>

<entry key="myscope" value-ref="myScope"></entry>

<entry key="simpleThreadScope" value-ref="simpleThreadScope"></entry>

</map>

</property>

</bean>

<bean id="bean11" class="main.java.com.自定义作用域.Bean" scope="simpleThreadScope"></bean>

测试代码：

public void testBean(){

final ApplicationContext ac=new ClassPathXmlApplicationContext("spring-zidingyi.xml");

for(int i=0;i<10;i++){

new Thread(new Runnable(){

@Override

public void run() {

Bean bean=ac.getBean("bean11", Bean.class);

System.out.println(bean);

}

}).start();

}

}

}

代码内容回顾

课程内容回顾

Web环境相关作用域

1、request作用域

bean标签的scope作用域设置为request后，每次请求，spring都会重新创建一个新的Bean。

2、session作用域

bean标签的scope作用域设置为session后，每个session都会被创建一个单独的实例。

3、application作用域

bean标签的scope作用域设置为application后，每个servletContext都会被创建一个单独的实例。

4、（不带传入）websocket作用域，使用很少，暂时忽略

bean标签的scope作用域设置为websocket后，每次请求，spring都会重新创建一个新的Bean。

因为是web应用作用域，所以程序应处于SpringWeb上下文环境，SpringMVC中就使用到了SpringWeb上下文环境。

建立SpringWeb上下文环境方式：

方式一：使用DispathcherServlet，不需要增加其他任何配置，因为这就是SpringWeb标准的上下文环境。

代码:

 <servlet-name>SpringWebContext</servlet-name>

  <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>

  <init-param>

  <param-name>contextConfigLocation</param-name>

  <param-value>classpath:spring.xml</param-value>

  </init-param>

  </servlet>

  <servlet-mapping>

  <servlet-name>SpringWebContext</servlet-name>

  <url-pattern>/*</url-pattern>

  </servlet-mapping>

方式二：不使用DispatcherServlet，那么需要增加listener或filter，取决于Servlet版本是2.4以上还是2.4以下。

（1）Servlet2.4以上

listener用处：在Web应用启动初始化过程中，加载一个SpringWeb的上下文。

代码：

<listener>

<listener-class>org.springframework.web.context.request.RequestContextListener

</listener-class>

</listener>

（2）Servlet2.4以下

filter作用：为每一个请求覆盖一个SpringWeb上下文。

代码：

<filter>

<filter-name>requestContextFilter</filter-name>

<filter-class>org.springframework.web.filter.RequestContextFilter</filter-class>

</filter>

<filter-mapping>

<filter-name>requestContextFilter</filter-name>

<url-pattern>/*</url-pattern>

<filter-mapping>

代码演示:这里用到了另外两个包——spring-web和spring-webmvc

步骤1：配置web.xml

@RequestMapping：在浏览器上通过URL路径去访问这个方法。

@ResponseBody：该注解下的方法返回值在浏览器上进行显示。

@Controller:放置在类上，spring可以通过它来找到该类。

代码：

@Controller

public class RequestScope {

@RequestMapping("testRequest")

@ResponseBody

public String test(){

return this.toString();

}

}

访问地址：http://localhost:8080/SpringWeb/testRequest，每次刷新都是会变化的。