Spring学习笔记之 Spring IOC容器(二) 之注入参数值，自动组件扫描方式，控制Bean实例化方式，使用注解方式...

最新推荐文章于 2024-05-28 09:25:21 发布
最新推荐文章于 2024-05-28 09:25:21 发布
阅读量46 收藏
点赞数
文章标签： java
原文链接：http://www.cnblogs.com/liuhongfeng/p/4582664.html
版权

 

 本节主要内容：
    1. 给MessageBean注入参数值
    2. 测试Spring自动组件扫描方式
    3. 如何控制ExampleBean实例化方式
    4. 使用注解方式重构JdbcDataSource, UserDAO, UserService

本文作者：souvc

本文出处：http://www.cnblogs.com/liuhongfeng/p/4582664.html 

 

1 给MessageBean注入参数值

1.1 问题

 

Spring可以通过配置文件为bean注入多种类型的属性, MessageBean类用于演示Spring的多种类型数据的注入方式, 这些类型数据和注入方式包括：

1. 注入基本值。

2. 注入Bean对象(请参考Unit 1案例)。

3. 直接集合注入。

4. 引用方式集合注入

5. 注入Spring表达式值。

6. 注入null或空字符串。

 

1.2 步骤

步骤一：新建工程，导入Spring API jar包

新建名为SouvcSpringIoC_02的web工程，在该工程导入5个jar包。

 
commons-logging.jar
spring-core.jar
spring-context.jar
spring-beans.jar
spring-expression.jar
 
网盘下载jar包 ：http://yunpan.cn/cQJhPMPRZeLH7  访问密码 2bf8

 

步骤二：新建Spring配置文件

在src目录下，新建Spring配置文件applicationContext.xml。该文件名为Spring默认的配置文件名，也可以自由定义名称。

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"
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:jdbc="http://www.springframework.org/schema/jdbc"
    xmlns:jee="http://www.springframework.org/schema/jee"
    xmlns:tx="http://www.springframework.org/schema/tx"
    xmlns:jpa="http://www.springframework.org/schema/data/jpa"
    xsi:schemaLocation="
            http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
            http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.2.xsd
            http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc-3.2.xsd
            http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-3.2.xsd
            http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.2.xsd
            http://www.springframework.org/schema/data/jpa http://www.springframework.org/schema/data/jpa/spring-jpa-1.3.xsd">






</beans>

 

 

步骤三：新建类MessageBean 添加基本值属性

新建类MessageBean，在该类中添加如下代码中的四个属性，并生成这几个属性对应的getter和setter方法；最后在execute方法获取这几个属性的信息，代码如下所示：

package com.souvc.bean;

public class MessageBean {
    private String moduleName;
    private int pageSize;
    private String username;
    private String password = "";

    public String getUsername() {
        return username;
    }

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

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public String getModuleName() {
        return moduleName;
    }

    public void setModuleName(String moduleName) {
        this.moduleName = moduleName;
    }

    public int getPageSize() {
        return pageSize;
    }

    public void setPageSize(int pageSize) {
        this.pageSize = pageSize;
    }

    public String execute() {
        System.out.println("moduleName=" + moduleName);
        System.out.println("pageSize=" + pageSize);
        System.out.println("username=" + username);
        System.out.println("password=" + password);
        System.out.println("---List信息如下---");
        return "success";
    }

}

 

步骤四：修改applicationContext.xml文件, 增加属性基本值注入

修改applicationContext.xml文件，为MessageBean的四个属性注入基本参数值，代码如图-3所示：

    <bean id="messagebean" class="com.souvc.bean.MessageBean">
        <property name="moduleName" value="测试基本属性"></property>
        <property name="pageSize" value="5"></property>
        <property name="username" value="daliu_it"></property>
        <property name="password" value="123456"></property>
    </bean>

 

步骤五：新建类Test1, 添加测试方法获取MessageBean对象测试注入结果

新建类Test1，在类中使用ApplicationContext的方式实例化Spring容器，获取MessageBean对象，并调用execute方法。

@Test
    public void test1() {
        String conf = "applicationContext.xml";
        ApplicationContext ac = new ClassPathXmlApplicationContext(conf);
        System.out.println(ac);

        MessageBean messagebean = ac.getBean("messagebean", MessageBean.class);
        System.out.println(messagebean.toString());
        messagebean.execute();
    }

 

步骤六：运行Test1类, 测试注入结果

运行Test1类，控制台输入结果

org.springframework.context.support.ClassPathXmlApplicationContext@65b4fad5: startup date [Wed Jun 17 11:16:13 CST 2015]; root of context hierarchy
com.souvc.bean.MessageBean@5d3e754f
moduleName=测试基本属性
pageSize=5
username=daliu_it
password=123456
---List信息如下---

 

控制台输出所示的信息，说明获取到了注入的基本属性值。

 

步骤七：为MessageBean添加集合属性,用于注入集合测试

1. 修改类MessageBean，在该类中添加如下加粗代码中的四个属性，并生成这几个属性对应的getter和setter方法；最后在execute方法获取这几个属性的信息，代码如下所示：

 
  •     private List<String> someList;
  •     private Set<String> someSet;
  •     private Map<String,Object> someMap;
  •     private Properties someProps;
  
package com.souvc.bean;

import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.Set;

public class MessageBean {
    private String moduleName;
    private int pageSize;
    private String username;
    private String password = "";

    
     private List<String> someList;
     private Set<String> someSet;
     private Map<String,Object> someMap;
     private Properties someProps;
    
    public String getUsername() {
        return username;
    }

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

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public String getModuleName() {
        return moduleName;
    }

    public void setModuleName(String moduleName) {
        this.moduleName = moduleName;
    }

    public int getPageSize() {
        return pageSize;
    }

    public void setPageSize(int pageSize) {
        this.pageSize = pageSize;
    }

    
    
    public List<String> getSomeList() {
        return someList;
    }

    public void setSomeList(List<String> someList) {
        this.someList = someList;
    }

    public Set<String> getSomeSet() {
        return someSet;
    }

    public void setSomeSet(Set<String> someSet) {
        this.someSet = someSet;
    }

    public Map<String, Object> getSomeMap() {
        return someMap;
    }

    public void setSomeMap(Map<String, Object> someMap) {
        this.someMap = someMap;
    }

    public Properties getSomeProps() {
        return someProps;
    }

    public void setSomeProps(Properties someProps) {
        this.someProps = someProps;
    }

    
    
    public String execute() {
        System.out.println("moduleName=" + moduleName);
        System.out.println("pageSize=" + pageSize);
        System.out.println("username=" + username);
        System.out.println("password=" + password);
        System.out.println("---List信息如下---");
    
        for(String s : someList){
            System.out.println(s);
        }
        System.out.println("---Set信息如下---");
        for(String s : someSet){
            System.out.println(s);
        }
        System.out.println("---Map信息如下---");
        Set<String> keys = someMap.keySet();
        for(String key : keys){
            System.out.println(key+"="
                    +someMap.get(key));
        }
        System.out.println("---Properties信息如下---");
        Set<Object> keys1 = someProps.keySet();
        for(Object key : keys1){
            System.out.println(key+"="
                    +someProps.getProperty(key.toString()));
        }
        
        
        return "success";
    }

}

 

2. 修改applicationContext.xml文件，为MessageBean的四个属性注入集合参数值：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:jdbc="http://www.springframework.org/schema/jdbc"
    xmlns:jee="http://www.springframework.org/schema/jee"
    xmlns:tx="http://www.springframework.org/schema/tx"
    xmlns:jpa="http://www.springframework.org/schema/data/jpa"
    xmlns:util="http://www.springframework.org/schema/util"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.2.xsd
        http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc-3.2.xsd
        http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-3.2.xsd
        http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.2.xsd
        http://www.springframework.org/schema/data/jpa http://www.springframework.org/schema/data/jpa/spring-jpa-1.3.xsd
        http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-3.2.xsd">



    <!-- 加载properties文件为bean
        <util:properties id="jdbcProperties"
        location="classpath:db.properties" /> -->


    <bean id="messagebean" class="com.souvc.bean.MessageBean">
        <property name="moduleName" value="测试基本属性的注入"></property>
        <property name="pageSize" value="5"></property>
        <!-- 表达式注入 -->
        <property name="username" value="daliu_it"></property>
        <property name="password" value="123456"></property>
        <property name="someList">
            <list>
                <value>北京</value>
                <value>上海</value>
                <value>广州</value>
            </list>
        </property>
        <property name="someSet">
            <set>
                <value>James Gosling</value>
                <value>Martin fowler</value>
                <value>Larry Ellision</value>
            </set>
        </property>
        <property name="someMap">
            <map>
                <entry key="1001" value="Java语言基础"></entry>
                <entry key="1002" value="Java Web基础"></entry>
                <entry key="1003" value="Spring使用基础"></entry>
            </map>
        </property>
        <property name="someProps">
            <props>
                <prop key="username">root</prop>
                <prop key="password">1234</prop>
            </props>
        </property>
    </bean>


    <!-- 定义集合Bean 
        <util:list id="oneList">
        <value>Tom</value>
        <value>Andy</value>
        </util:list>
        <util:set id="oneSet">
        <value>James Gosling</value>
        <value>Martin fowler</value>
        </util:set>
        <util:map id="oneMap">
        <entry key="1001" value="Java语言基础"></entry>
        <entry key="1002" value="Java Web基础"></entry>
        </util:map>
        <util:properties id="oneProps">
        <prop key="username">root</prop>
        <prop key="password">1234</prop>
        </util:properties>
        
    -->

    <!-- 引用方式注入集合属性 
        <bean id="messagebean2" class="com.souvc.bean.MessageBean">
        <property name="moduleName" value="资费管理"></property>
        <property name="pageSize" value="5"></property>
        <property name="username" value="andy"></property>
        <property name="password" value="123"></property>-->

    <!-- 引用方式注入集合属性 
        <property name="someList" ref="oneList" />
        <property name="someSet" ref="oneSet" />
        <property name="someMap" ref="oneMap" />
        <property name="someProps" ref="oneProps" />
        </bean>-->
</beans>

 



3. 运行Test1类，控制台输出结果所示：

  
org.springframework.context.support.ClassPathXmlApplicationContext@42704baa: startup date [Wed Jun 17 11:30:43 CST 2015]; root of context hierarchy
com.souvc.bean.MessageBean@25961581
moduleName=测试基本属性的注入
pageSize=5
username=daliu_it
password=123456
---List信息如下---
北京
上海
广州
---Set信息如下---
James Gosling
Martin fowler
Larry Ellision
---Map信息如下---
1001=Java语言基础
1002=Java Web基础
1003=Spring使用基础
---Properties信息如下---
password=1234
username=root

 

控制台输出的信息，说明只需要通过配置Spring就可以为Bean注入集合参数值。

 

步骤八：测试引用方式集合注入

1.为Spring配置文件applicationContext.xml增加如下配置, 采用引用方式注入集合对象, 代码参考如下:

<!-- 定义集合Bean -->
    <util:list id="oneList">
        <value>Tom</value>
        <value>Andy</value>
    </util:list>
    <util:set id="oneSet">
        <value>James Gosling</value>
        <value>Martin fowler</value>
    </util:set>
    <util:map id="oneMap">
        <entry key="1001" value="Java语言基础"></entry>
        <entry key="1002" value="Java Web基础"></entry>
    </util:map>
    <util:properties id="oneProps">
        <prop key="username">root</prop>
        <prop key="password">1234</prop>
    </util:properties>



    <!-- 引用方式注入集合属性 -->
    <bean id="messagebean2" class="com.souvc.bean.MessageBean">
        <property name="moduleName" value="资费管理"></property>
        <property name="pageSize" value="5"></property>
        <property name="username" value="andy"></property>
        <property name="password" value="123"></property>

        <!-- 引用方式注入集合属性 -->
        <property name="someList" ref="oneList" />
        <property name="someSet" ref="oneSet" />
        <property name="someMap" ref="oneMap" />
        <property name="someProps" ref="oneProps" />
    </bean>

 

 

2. 增加Test2类测试如上配置, Test2代码如下:

package com.souvc.test;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.souvc.bean.MessageBean;

public class TestCase {

    @Test
    public void test1() {
        String conf = "applicationContext.xml";
        ApplicationContext ac = new ClassPathXmlApplicationContext(conf);
        System.out.println(ac);

        MessageBean messagebean = ac.getBean("messagebean", MessageBean.class);
        System.out.println(messagebean.toString());
        messagebean.execute();
    }

    @Test
    public void test2() {
        String conf = "applicationContext.xml";
        ApplicationContext ac = new ClassPathXmlApplicationContext(conf);
        MessageBean bean = ac.getBean("messagebean2", MessageBean.class);
        bean.execute();
    }
}

 

 
 

3. 执行Test2 有如下结果所示:

moduleName=资费管理
pageSize=5
username=andy
password=123
---List信息如下---
Tom
Andy
---Set信息如下---
James Gosling
Martin fowler
---Map信息如下---
1001=Java语言基础
1002=Java Web基础
---Properties信息如下---
password=1234
username=root

 

这个结果说明, 通过引用方式也可以为bean注入集合属性.

步骤九：利用 Spring表达式注入属性值

1.在工程的src下，新建属性文件db.properties，文件内容如下:

    user=scott

2. 修改applicationContext.xml文件，注入Spring表达式值，代码所示：

<!-- 加载properties文件为bean -->
 <util:properties id="jdbcProperties" location="classpath:db.properties" />
 
 
 <bean id="messagebean" class="org.tarena.bean.MessageBean">
 
  <!-- ================================================================ -->
 
  <property name="moduleName" value="资费管理"></property>
  <property name="pageSize" value="5"></property>
  <!-- 表达式注入 -->
  <property name="username" value="#{jdbcProperties.user}"></property>
 
  <property name="password">
   <null />
  </property>

 

3. 运行Test1类，控制台输出结果所示：

org.springframework.context.support.ClassPathXmlApplicationContext@68861f24: startup date [Wed Jun 17 11:41:35 CST 2015]; root of context hierarchy
com.souvc.bean.MessageBean@209444d1
moduleName=测试基本属性的注入
pageSize=5
username=daliu_it
password=123456
---List信息如下---
北京
上海
广州
---Set信息如下---
James Gosling
Martin fowler
Larry Ellision
---Map信息如下---
1001=Java语言基础
1002=Java Web基础
1003=Spring使用基础
---Properties信息如下---
password=1234
username=root

 

控制台输出信息，说明获取到了注入的Spring表达式值。

 

步骤十：注入null值

1. 修改applicationContext.xml文件，将属性password注入null值，代码如图-11所示：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:jdbc="http://www.springframework.org/schema/jdbc"
    xmlns:jee="http://www.springframework.org/schema/jee"
    xmlns:tx="http://www.springframework.org/schema/tx"
    xmlns:jpa="http://www.springframework.org/schema/data/jpa"
    xmlns:util="http://www.springframework.org/schema/util"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.2.xsd
        http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc-3.2.xsd
        http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-3.2.xsd
        http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.2.xsd
        http://www.springframework.org/schema/data/jpa http://www.springframework.org/schema/data/jpa/spring-jpa-1.3.xsd
        http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-3.2.xsd">



    <!-- 加载properties文件为bean-->
    <util:properties id="jdbcProperties"
        location="classpath:db.properties" />


    <bean id="messagebean" class="com.souvc.bean.MessageBean">
        <property name="moduleName" value="测试基本属性的注入"></property>
        <property name="pageSize" value="5"></property>
        <!-- 表达式注入 
            <property name="username" value="daliu_it"></property>-->
        <property name="username" value="#{jdbcProperties.user}"></property>
        <property name="password" >
        <null/>
        </property>
        <property name="someList">
            <list>
                <value>北京</value>
                <value>上海</value>
                <value>广州</value>
            </list>
        </property>
        <property name="someSet">
            <set>
                <value>James Gosling</value>
                <value>Martin fowler</value>
                <value>Larry Ellision</value>
            </set>
        </property>
        <property name="someMap">
            <map>
                <entry key="1001" value="Java语言基础"></entry>
                <entry key="1002" value="Java Web基础"></entry>
                <entry key="1003" value="Spring使用基础"></entry>
            </map>
        </property>
        <property name="someProps">
            <props>
                <prop key="username">root</prop>
                <prop key="password">1234</prop>
            </props>
        </property>
    </bean>


    <!-- 定义集合Bean -->
    <util:list id="oneList">
        <value>Tom</value>
        <value>Andy</value>
    </util:list>
    <util:set id="oneSet">
        <value>James Gosling</value>
        <value>Martin fowler</value>
    </util:set>
    <util:map id="oneMap">
        <entry key="1001" value="Java语言基础"></entry>
        <entry key="1002" value="Java Web基础"></entry>
    </util:map>
    <util:properties id="oneProps">
        <prop key="username">root</prop>
        <prop key="password">1234</prop>
    </util:properties>



    <!-- 引用方式注入集合属性 -->
    <bean id="messagebean2" class="com.souvc.bean.MessageBean">
        <property name="moduleName" value="资费管理"></property>
        <property name="pageSize" value="5"></property>
        <property name="username" value="andy"></property>
        <property name="password" value="123"></property>

        <!-- 引用方式注入集合属性 -->
        <property name="someList" ref="oneList" />
        <property name="someSet" ref="oneSet" />
        <property name="someMap" ref="oneMap" />
        <property name="someProps" ref="oneProps" />
    </bean>
</beans>

 


 

2. 运行Test1类，控制台输出结果：

org.springframework.context.support.ClassPathXmlApplicationContext@2996c1b0: startup date [Wed Jun 17 11:42:47 CST 2015]; root of context hierarchy
com.souvc.bean.MessageBean@195ed659
moduleName=测试基本属性的注入
pageSize=5
username=daliu_it
password=null
---List信息如下---
北京
上海
广州
---Set信息如下---
James Gosling
Martin fowler
Larry Ellision
---Map信息如下---
1001=Java语言基础
1002=Java Web基础
1003=Spring使用基础
---Properties信息如下---
password=1234
username=root

 

控制台输出所示的信息，说明获取到了注入的null值。

1.3 完整代码

MessageBean类的完整代码如下所示：

package com.souvc.bean;

import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.Set;

public class MessageBean {
    private String moduleName;
    private int pageSize;
    private String username;
    private String password = "";

    private List<String> someList;
    private Set<String> someSet;
    private Map<String, Object> someMap;
    private Properties someProps;

    public String getUsername() {
        return username;
    }

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

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public String getModuleName() {
        return moduleName;
    }

    public void setModuleName(String moduleName) {
        this.moduleName = moduleName;
    }

    public int getPageSize() {
        return pageSize;
    }

    public void setPageSize(int pageSize) {
        this.pageSize = pageSize;
    }

    public List<String> getSomeList() {
        return someList;
    }

    public void setSomeList(List<String> someList) {
        this.someList = someList;
    }

    public Set<String> getSomeSet() {
        return someSet;
    }

    public void setSomeSet(Set<String> someSet) {
        this.someSet = someSet;
    }

    public Map<String, Object> getSomeMap() {
        return someMap;
    }

    public void setSomeMap(Map<String, Object> someMap) {
        this.someMap = someMap;
    }

    public Properties getSomeProps() {
        return someProps;
    }

    public void setSomeProps(Properties someProps) {
        this.someProps = someProps;
    }

    public String execute() {
        System.out.println("moduleName=" + moduleName);
        System.out.println("pageSize=" + pageSize);
        System.out.println("username=" + username);
        System.out.println("password=" + password);
        System.out.println("---List信息如下---");

        for (String s : someList) {
            System.out.println(s);
        }
        System.out.println("---Set信息如下---");
        for (String s : someSet) {
            System.out.println(s);
        }
        System.out.println("---Map信息如下---");
        Set<String> keys = someMap.keySet();
        for (String key : keys) {
            System.out.println(key + "=" + someMap.get(key));
        }
        System.out.println("---Properties信息如下---");
        Set<Object> keys1 = someProps.keySet();
        for (Object key : keys1) {
            System.out.println(key + "="
                    + someProps.getProperty(key.toString()));
        }

        return "success";
    }

}

 

Test1，Test2的完整代码如下：

package com.souvc.test;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.souvc.bean.MessageBean;

public class TestCase {

    @Test
    public void test1() {
        String conf = "applicationContext.xml";
        ApplicationContext ac = new ClassPathXmlApplicationContext(conf);
        System.out.println(ac);

        MessageBean messagebean = ac.getBean("messagebean", MessageBean.class);
        System.out.println(messagebean.toString());
        messagebean.execute();
    }

    @Test
    public void test2() {
        String conf = "applicationContext.xml";
        ApplicationContext ac = new ClassPathXmlApplicationContext(conf);
        MessageBean bean = ac.getBean("messagebean2", MessageBean.class);
        bean.execute();
    }
}

 

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"
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:jdbc="http://www.springframework.org/schema/jdbc"
    xmlns:jee="http://www.springframework.org/schema/jee"
    xmlns:tx="http://www.springframework.org/schema/tx"
    xmlns:jpa="http://www.springframework.org/schema/data/jpa"
    xmlns:util="http://www.springframework.org/schema/util"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.2.xsd
        http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc-3.2.xsd
        http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-3.2.xsd
        http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.2.xsd
        http://www.springframework.org/schema/data/jpa http://www.springframework.org/schema/data/jpa/spring-jpa-1.3.xsd
        http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-3.2.xsd">



    <!-- 加载properties文件为bean-->
    <util:properties id="jdbcProperties"
        location="classpath:db.properties" />


    <bean id="messagebean" class="com.souvc.bean.MessageBean">
        <property name="moduleName" value="测试基本属性的注入"></property>
        <property name="pageSize" value="5"></property>
        <!-- 表达式注入 
            <property name="username" value="daliu_it"></property>-->
        <property name="username" value="#{jdbcProperties.user}"></property>
        <property name="password" >
        <null/>
        </property>
        <property name="someList">
            <list>
                <value>北京</value>
                <value>上海</value>
                <value>广州</value>
            </list>
        </property>
        <property name="someSet">
            <set>
                <value>James Gosling</value>
                <value>Martin fowler</value>
                <value>Larry Ellision</value>
            </set>
        </property>
        <property name="someMap">
            <map>
                <entry key="1001" value="Java语言基础"></entry>
                <entry key="1002" value="Java Web基础"></entry>
                <entry key="1003" value="Spring使用基础"></entry>
            </map>
        </property>
        <property name="someProps">
            <props>
                <prop key="username">root</prop>
                <prop key="password">1234</prop>
            </props>
        </property>
    </bean>


    <!-- 定义集合Bean -->
    <util:list id="oneList">
        <value>Tom</value>
        <value>Andy</value>
    </util:list>
    <util:set id="oneSet">
        <value>James Gosling</value>
        <value>Martin fowler</value>
    </util:set>
    <util:map id="oneMap">
        <entry key="1001" value="Java语言基础"></entry>
        <entry key="1002" value="Java Web基础"></entry>
    </util:map>
    <util:properties id="oneProps">
        <prop key="username">root</prop>
        <prop key="password">1234</prop>
    </util:properties>



    <!-- 引用方式注入集合属性 -->
    <bean id="messagebean2" class="com.souvc.bean.MessageBean">
        <property name="moduleName" value="资费管理"></property>
        <property name="pageSize" value="5"></property>
        <property name="username" value="andy"></property>
        <property name="password" value="123"></property>

        <!-- 引用方式注入集合属性 -->
        <property name="someList" ref="oneList" />
        <property name="someSet" ref="oneSet" />
        <property name="someMap" ref="oneMap" />
        <property name="someProps" ref="oneProps" />
    </bean>
</beans>

 

源码如下：http://yunpan.cn/cQVU3sLcMzXGC  访问密码 daf3

 

2 测试Spring自动组件扫描方式

2.1 问题

如何使用组件扫描的方式和"注解标记"配合获取容器中的ExampleBean对象。

2.2 方案

使用组件扫描，首先需要在XML配置中指定扫描类路径，配置代码如下：

 

    <context:component-scan 
                  base-package="com.souvc"/>

 

上述配置，容器实例化时会自动扫描com.souvc 包及其子包下所有组件类。

指定扫描类路径后，并不是该路径下所有组件类都扫描到Spring容器的，只有在组件类定义前面有以下注解标记时，才会扫描到Spring容器。


@Component  泛指组件，当组件不好归类的时候，我们可以使用这个注解进行标注。

@Name 通用注解

@Service  业务层组件注解， 用于标注业务层组件

@Repository  持久层组件注解，用于标注数据访问组件，即DAO组件

@Controller  控制层组件注解，用于标注控制层组件（如struts中的action）

 

2.3 步骤

步骤一：新建类ExampleBean

新建类ExampleBean，在该类前使用通用组件注解“@Component”，表明ExampleBean为可被扫描的组件，代码如下所示：

package com.souvc.bean;

import org.springframework.stereotype.Component;

@Component
public class ExampleBean {

    public ExampleBean() {
        System.out.println("实例化ExampleBean");
    }

    public void execute() {
        System.out.println("执行ExampleBean处理");
    }
}

 

 

步骤二： 修改applicationContext.xml

修改applicationContext.xml，使容器实例化时自动扫描org.tarena包及其子包下所有组件类

  
<!-- 组件扫描 -->
    <context:component-scan base-package="com.souvc" />

 

步骤三： 新建方法Test3

 

@Test
    public void test3() {
        String conf = "applicationContext.xml";
        ApplicationContext ac = new ClassPathXmlApplicationContext(conf);
        ExampleBean bean = ac.getBean("exampleBean", ExampleBean.class);
        bean.execute();
    }

 

运行Test3方法，控制台输出结果：


实例化ExampleBean
执行ExampleBean处理

 

控制台输出上述结果，说明Spring会自动使用组件扫描的方式创建ExampleBean实例, 并且Test3中获取到了这个ExampleBean对象。

2.4 完整代码

ExampleBean类的完整代码如下所示：

package com.souvc.bean;

import org.springframework.stereotype.Component;

@Component
public class ExampleBean {

    public ExampleBean() {
        System.out.println("实例化ExampleBean");
    }

    public void execute() {
        System.out.println("执行ExampleBean处理");
    }
}

 

TestCase 类的完整代码如下所示：

package com.souvc.test;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.souvc.bean.ExampleBean;
import com.souvc.bean.MessageBean;

public class TestCase {

    @Test
    public void test1() {
        String conf = "applicationContext.xml";
        ApplicationContext ac = new ClassPathXmlApplicationContext(conf);
        System.out.println(ac);

        MessageBean messagebean = ac.getBean("messagebean", MessageBean.class);
        System.out.println(messagebean.toString());
        messagebean.execute();
    }

    @Test
    public void test2() {
        String conf = "applicationContext.xml";
        ApplicationContext ac = new ClassPathXmlApplicationContext(conf);
        MessageBean bean = ac.getBean("messagebean2", MessageBean.class);
        bean.execute();
    }

    @Test
    public void test3() {
        String conf = "applicationContext.xml";
        ApplicationContext ac = new ClassPathXmlApplicationContext(conf);
        ExampleBean bean = ac.getBean("exampleBean", ExampleBean.class);
        bean.execute();
    }
}

 

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"
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:jdbc="http://www.springframework.org/schema/jdbc"
    xmlns:jee="http://www.springframework.org/schema/jee"
    xmlns:tx="http://www.springframework.org/schema/tx"
    xmlns:jpa="http://www.springframework.org/schema/data/jpa"
    xmlns:util="http://www.springframework.org/schema/util"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.2.xsd
        http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc-3.2.xsd
        http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-3.2.xsd
        http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.2.xsd
        http://www.springframework.org/schema/data/jpa http://www.springframework.org/schema/data/jpa/spring-jpa-1.3.xsd
        http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-3.2.xsd">



    <!-- 加载properties文件为bean-->
    <util:properties id="jdbcProperties"
        location="classpath:db.properties" />


    <bean id="messagebean" class="com.souvc.bean.MessageBean">
        <property name="moduleName" value="测试基本属性的注入"></property>
        <property name="pageSize" value="5"></property>
        <!-- 表达式注入 
            <property name="username" value="daliu_it"></property>-->
        <property name="username" value="#{jdbcProperties.user}"></property>
        <property name="password">
            <null />
        </property>
        <property name="someList">
            <list>
                <value>北京</value>
                <value>上海</value>
                <value>广州</value>
            </list>
        </property>
        <property name="someSet">
            <set>
                <value>James Gosling</value>
                <value>Martin fowler</value>
                <value>Larry Ellision</value>
            </set>
        </property>
        <property name="someMap">
            <map>
                <entry key="1001" value="Java语言基础"></entry>
                <entry key="1002" value="Java Web基础"></entry>
                <entry key="1003" value="Spring使用基础"></entry>
            </map>
        </property>
        <property name="someProps">
            <props>
                <prop key="username">root</prop>
                <prop key="password">1234</prop>
            </props>
        </property>
    </bean>


    <!-- 定义集合Bean -->
    <util:list id="oneList">
        <value>Tom</value>
        <value>Andy</value>
    </util:list>
    <util:set id="oneSet">
        <value>James Gosling</value>
        <value>Martin fowler</value>
    </util:set>
    <util:map id="oneMap">
        <entry key="1001" value="Java语言基础"></entry>
        <entry key="1002" value="Java Web基础"></entry>
    </util:map>
    <util:properties id="oneProps">
        <prop key="username">root</prop>
        <prop key="password">1234</prop>
    </util:properties>



    <!-- 引用方式注入集合属性 -->
    <bean id="messagebean2" class="com.souvc.bean.MessageBean">
        <property name="moduleName" value="资费管理"></property>
        <property name="pageSize" value="5"></property>
        <property name="username" value="andy"></property>
        <property name="password" value="123"></property>

        <!-- 引用方式注入集合属性 -->
        <property name="someList" ref="oneList" />
        <property name="someSet" ref="oneSet" />
        <property name="someMap" ref="oneMap" />
        <property name="someProps" ref="oneProps" />
    </bean>


    <!-- 组件扫描 -->
    <context:component-scan base-package="com.souvc" />


</beans>

 

 

3 如何控制ExampleBean实例化方式

3.1 问题

使用组件扫描的方式，重构如何控制ExampleBean实例化为单例或非单例模式。

3.2 方案

1. 通常受Spring管理的组件，默认的作用域是"singleton"。如果需要其他的作用域可以使用@Scope注解，只要在注解中提供作用域的名称即可，代码如下：

    @Component
    @Scope("singleton")
    public class ExampleBean {
       ...
        }

 

2. @PostConstruct和@PreDestroy注解标记分别用于指定初始化和销毁回调方法，代码如下：

    public class ExampleBean { 
          @PostConstruct 
          public void init() {
                //初始化回调方法
          } 
          
          @PreDestroy 
          public void destroy() { 
                 //销毁回调方法
           }
     }

 

 

3.3 步骤

步骤一：Bean对象的创建模式

1． 修改ExampleBean，使用prototype模式创建 ExampleBean 对象，修改的代码：

package com.souvc.bean;

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;

import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;

@Component
@Scope("prototype")
public class ExampleBean {

    public ExampleBean() {
        System.out.println("实例化ExampleBean");
    }

//    public void execute() {
//        System.out.println("执行ExampleBean处理");
//    }
//
//    @PostConstruct
//    public void init() {
//        System.out.println("初始化ExampleBean对象");
//    }
//
//    @PreDestroy
//    public void destroy() {
//        System.out.println("销毁ExampleBean对象");
//    }
}

 

2． 新建类Test4在该类中创建两个ExampleBean对象，通过比较操作符==进行比较，代码如图-19所示：

    @Test
    public void test4() {
        String conf = "applicationContext.xml";
        AbstractApplicationContext ac = new ClassPathXmlApplicationContext(conf);
        ExampleBean bean1 = ac.getBean("exampleBean", ExampleBean.class);
        ExampleBean bean2 = ac.getBean("exampleBean", ExampleBean.class);
        System.out.println(bean1 == bean2);
        ac.close();
    }

 

3． 运行Test4，控制台输出结果如下：

实例化ExampleBean
实例化ExampleBean
false

 

通过前面的讲解，了解到默认情况下Spring容器是通过单例模式创建Bean对象的。通过本案例的运行结果，可以看出使用原型方式，调用了2次ExampleBean类的构造方法，说明创建了2个ExampleBean对象。

4. 如果想要使用单例模式创建对象，也可以使用注解的方式进行显示标注，修改ExampleBean类的代码所示：

package com.souvc.bean;

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;

import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;

@Component
//@Scope("prototype")
@Scope("singleton")
public class ExampleBean {

    public ExampleBean() {
        System.out.println("实例化ExampleBean");
    }

//    public void execute() {
//        System.out.println("执行ExampleBean处理");
//    }
//
//    @PostConstruct
//    public void init() {
//        System.out.println("初始化ExampleBean对象");
//    }
//
//    @PreDestroy
//    public void destroy() {
//        System.out.println("销毁ExampleBean对象");
//    }
}

 

5． 再次运行Test4，控制台输出结果如下：

实例化ExampleBean
true
 

上述运行结果可以看得出，两个ExampleBean对象，通过比较操作符“ ==”进行比较的输出结果为true，说明Spring容器是通过单例模式创建Bean对象的。

步骤二：Bean对象的初始化和销毁

1. 修改ExampleBean类，加入方法init和方法destroy，并使用注解“@PostConstruct”和注解“@PreDestroy”指定init为初始化的回调方法、destroy为销毁的回调方法，代码如下所示：

package com.souvc.bean;

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;

import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;

@Component
//@Scope("prototype")
@Scope("singleton")
public class ExampleBean {

    public ExampleBean() {
        System.out.println("实例化ExampleBean");
    }

    public void execute() {
        System.out.println("执行ExampleBean处理");
    }

    @PostConstruct
    public void init() {
        System.out.println("初始化ExampleBean对象");
    }

    @PreDestroy
    public void destroy() {
        System.out.println("销毁ExampleBean对象");
    }
}

 

2.运行Test4类，控制台输出结果所示：

实例化ExampleBean
初始化ExampleBean对象
true
2015-6-17 14:26:05 org.springframework.context.support.AbstractApplicationContext doClose
信息: Closing org.springframework.context.support.ClassPathXmlApplicationContext@45b9ce4b: startup date [Wed Jun 17 14:26:04 CST 2015]; root of context hierarchy
2015-6-17 14:26:05 org.springframework.beans.factory.support.DefaultSingletonBeanRegistry destroySingletons
信息: Destroying singletons in org.springframework.beans.factory.support.DefaultListableBeanFactory@36f0b7f8: defining beans [jdbcProperties,messagebean,oneList,oneSet,oneMap,oneProps,messagebean2,exampleBean,org.springframework.context.annotation.internalConfigurationAnnotationProcessor,org.springframework.context.annotation.internalAutowiredAnnotationProcessor,org.springframework.context.annotation.internalRequiredAnnotationProcessor,org.springframework.context.annotation.internalCommonAnnotationProcessor,org.springframework.context.annotation.ConfigurationClassPostProcessor.importAwareProcessor]; root of factory hierarchy
销毁ExampleBean对象

 

控制台输出了“初始化ExampleBean对象”和“销毁ExampleBean对象”，说明使用组件扫描的方式为ExampleBean类添加初始化和销毁的回调方法成功。

3.4 完整代码

ExampleBean类的完整代码如下所示：

package com.souvc.bean;

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;

import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;

@Component
//@Scope("prototype")
@Scope("singleton")
public class ExampleBean {

    public ExampleBean() {
        System.out.println("实例化ExampleBean");
    }

    public void execute() {
        System.out.println("执行ExampleBean处理");
    }

    @PostConstruct
    public void init() {
        System.out.println("初始化ExampleBean对象");
    }

    @PreDestroy
    public void destroy() {
        System.out.println("销毁ExampleBean对象");
    }
}

 

 

Test4类的完整代码如下所示：

package com.souvc.test;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.AbstractApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.souvc.bean.ExampleBean;
import com.souvc.bean.MessageBean;

public class TestCase {

    @Test
    public void test1() {
        String conf = "applicationContext.xml";
        ApplicationContext ac = new ClassPathXmlApplicationContext(conf);
        System.out.println(ac);

        MessageBean messagebean = ac.getBean("messagebean", MessageBean.class);
        System.out.println(messagebean.toString());
        messagebean.execute();
    }

    @Test
    public void test2() {
        String conf = "applicationContext.xml";
        ApplicationContext ac = new ClassPathXmlApplicationContext(conf);
        MessageBean bean = ac.getBean("messagebean2", MessageBean.class);
        bean.execute();
    }

    @Test
    public void test3() {
        String conf = "applicationContext.xml";
        ApplicationContext ac = new ClassPathXmlApplicationContext(conf);
        ExampleBean bean = ac.getBean("exampleBean", ExampleBean.class);
        //bean.execute();
    }

    @Test
    public void test4() {
        String conf = "applicationContext.xml";
        AbstractApplicationContext ac = new ClassPathXmlApplicationContext(conf);
        ExampleBean bean1 = ac.getBean("exampleBean", ExampleBean.class);
        ExampleBean bean2 = ac.getBean("exampleBean", ExampleBean.class);
        System.out.println(bean1 == bean2);
        ac.close();
    }

}

 

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"
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:jdbc="http://www.springframework.org/schema/jdbc"
    xmlns:jee="http://www.springframework.org/schema/jee"
    xmlns:tx="http://www.springframework.org/schema/tx"
    xmlns:jpa="http://www.springframework.org/schema/data/jpa"
    xmlns:util="http://www.springframework.org/schema/util"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.2.xsd
        http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc-3.2.xsd
        http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-3.2.xsd
        http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.2.xsd
        http://www.springframework.org/schema/data/jpa http://www.springframework.org/schema/data/jpa/spring-jpa-1.3.xsd
        http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-3.2.xsd">



    <!-- 加载properties文件为bean-->
    <util:properties id="jdbcProperties"
        location="classpath:db.properties" />


    <bean id="messagebean" class="com.souvc.bean.MessageBean">
        <property name="moduleName" value="测试基本属性的注入"></property>
        <property name="pageSize" value="5"></property>
        <!-- 表达式注入 
            <property name="username" value="daliu_it"></property>-->
        <property name="username" value="#{jdbcProperties.user}"></property>
        <property name="password">
            <null />
        </property>
        <property name="someList">
            <list>
                <value>北京</value>
                <value>上海</value>
                <value>广州</value>
            </list>
        </property>
        <property name="someSet">
            <set>
                <value>James Gosling</value>
                <value>Martin fowler</value>
                <value>Larry Ellision</value>
            </set>
        </property>
        <property name="someMap">
            <map>
                <entry key="1001" value="Java语言基础"></entry>
                <entry key="1002" value="Java Web基础"></entry>
                <entry key="1003" value="Spring使用基础"></entry>
            </map>
        </property>
        <property name="someProps">
            <props>
                <prop key="username">root</prop>
                <prop key="password">1234</prop>
            </props>
        </property>
    </bean>


    <!-- 定义集合Bean -->
    <util:list id="oneList">
        <value>Tom</value>
        <value>Andy</value>
    </util:list>
    <util:set id="oneSet">
        <value>James Gosling</value>
        <value>Martin fowler</value>
    </util:set>
    <util:map id="oneMap">
        <entry key="1001" value="Java语言基础"></entry>
        <entry key="1002" value="Java Web基础"></entry>
    </util:map>
    <util:properties id="oneProps">
        <prop key="username">root</prop>
        <prop key="password">1234</prop>
    </util:properties>



    <!-- 引用方式注入集合属性 -->
    <bean id="messagebean2" class="com.souvc.bean.MessageBean">
        <property name="moduleName" value="资费管理"></property>
        <property name="pageSize" value="5"></property>
        <property name="username" value="andy"></property>
        <property name="password" value="123"></property>

        <!-- 引用方式注入集合属性 -->
        <property name="someList" ref="oneList" />
        <property name="someSet" ref="oneSet" />
        <property name="someMap" ref="oneMap" />
        <property name="someProps" ref="oneProps" />
    </bean>


    <!-- 组件扫描 -->
    <context:component-scan base-package="com.souvc" />


</beans>

 

 

本文作者：souvc

本文出处：http://www.cnblogs.com/liuhongfeng/p/4582664.html 

 

转载于:https://www.cnblogs.com/liuhongfeng/p/4582664.html

weixin_30622181
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Spring为IOC容器注入Bean的五种方式详解
08-25
主要介绍了Spring为IOC容器注入Bean的五种方式详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
Spring bean的实例化和IOC依赖注入详解
08-26
主要介绍了Spring bean的实例化和IOC依赖注入详解，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
Spring之IOC容器(依赖注入)&基本介绍&基本配置&多模块化
weixin_73817220的博客
09-15 201
Spring是一个开源框架，它由Rod Johnson创建。它是为了解决企业应用开发的复杂性而创建的。Spring使用基本的JavaBean来完成以前只可能由EJB完成的事情。然而，Spring的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言，任何Java应用都可以从Spring中受益。Spring项目出发点：目的：提供一种贯穿始终的解决方面，将各种专用框架整合成一个连贯的整体框架，简化企业级应用的开发（有点像粘合剂）
Spring第三阶段：IOC获取对象与参数注入方式
DKPT的博客
04-21 239
Spring第三阶段：IOC获取对象与参数注入方式
spring 第二节参数值注入，基于注解的组件扫描
zerolaw的博客
07-17 333
  1，信息注入 自动注入，简化注入的配置 autowire set自动注入，以什么样的规则呢？这个里面是一个默认的，约定的 autowire=“byType”，按类型匹配往里面注入，那现在这个student的话，它里面有computer和phone变量，和set方法，他会尝试给set方法找这两个变量的对应的信息，给它往里面传，这里不是类型匹配吗，我们就从spring容器当中，我就去找...
包扫描自定义注解类并实例化
weixin_34378969的博客
12-07 446
1. 新建Maven 项目 annotation 2. pom.xml <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://mave...
Spring学习入门：IoC、DI、bean配置和实例化、依赖注入、容器、注解开发、AOP、整合MyBatis、事务...【建议收藏】
RuanFun的博客
08-28 283
全面讲解Spring基础技术，适合新手入门：IoC、DI、bean配置和实例化、依赖注入、容器、注解开发、AOP、整合MyBatis、事务....
Spring学习笔记1之IOC详解尽量使用注解以及java代码
09-02
主要介绍了Spring学习笔记1之IOC详解尽量使用注解以及java代码 的相关资料,需要的朋友可以参考下
浅谈spring ioc的注入方式及注入不同的数据类型
08-28
主要介绍了浅谈spring ioc的注入方式及注入不同的数据类型，具有一定借鉴价值,需要的朋友可以参考下
浅谈springioc实例化bean的三个方法
08-29
下面小编就为大家带来一篇浅谈springioc实例化bean的三个方法。小编觉得挺不错的，现在就想给大家，也给大家做个参考。一起跟随小编过来看看吧
参数值注入 、基于注解的组件扫描
热门推荐
羽翼冰蓝
07-05 2万+
基于注解的组件扫描——Spring IOC/DI（五）
方圆几里
10-24 829
上一章我们讲了无注解的自动装配： https://blog.csdn.net/qq_34598667/article/details/83317377 这一章我们讲一下基于注解的装配，组件扫描 基于注解的组件扫描 案例准备： 之前案例com.oak.entity中的Person类 public class Person { private String name; private Integ...
execute 使用方法
dingqiang305的专栏
03-11 4896
点击打开链接 使用方法 execute 　　execute 方法应该仅在语句能返回多个 ResultSet 对象、多个更新计数或 ResultSet 对象与更新计数的组合时使用。当执行某个已存储过程或动态执行未知 SQL 字符串（即应用程序程序员在编译时未知）时，有可能出现多个结果的情况，尽管这种情况很少见。例如，用户可能执行一个已存储过程（使用 CallableStatement
java学习和项目总结
2301_79390585的博客
05-24 626
JRE：JRE是Java 运行时环境，主要包括了两个运行需要的组件：JVM 和 Java 核心类库，如果不进行java开发只想运行就可以只下载JRE。而Java语言，它的代码会先通过javac编译成字节码，再通过jvm将字节码转换成机器码（0和1）执行，即解释运行和编译运行配合使用，所以是混合型。在程序运行之前，通过编译器将源程序编译成机器码可运行的二进制，以后执行这个程序时，就不用再进行编译了。JVM：JVM是java进行编译的虚拟机，是Java 能够跨平台运行的核心。特点：执行速度慢、效率低；
Java高级面试精粹：问题与解答集锦（一）
Layla_c的博客
05-23 1377
答案多态是Java中的一个核心概念，它允许不同类的对象对同一消息做出响应，但具体的行为会根据对象的实际类型而有所不同。重载（Overloading）：当多个方法具有相同的名称，但参数列表不同时，这称为方法重载。编译器根据方法调用时传递的参数类型和数量来确定调用哪个方法。重写（Overriding）：当子类有一个与父类同名、同参数列表的方法时，子类可以提供特定的实现来覆盖父类的方法。运行时，Java虚拟机（JVM）会根据对象的实际类型调用相应的方法，这个过程称为动态绑定或晚期绑定。答案。
数据访问与Spring Data JPA
无远弗届
05-25 482
假设我们要处理一个用户表（users），可以创建一个User@Entity // 标识这是一个实体类 public class User {@Id // 标识这是主键字段 @GeneratedValue(strategy = GenerationType . AUTO) // 主键生成策略 private Long id;// Getter 和 Setter ... }@Entity // 标识这是一个实体类 public class User {
operator ＜=＞ (spaceship operator)
最新发布
janeqi1987的专栏
05-28 581
= 与!= 操作符为了检查是否相等，现在定义== 操作符就够了。当编译器找不到表达式的匹配声明a!=b 时，编译器会重写表达式并查找!(a==b)。若这不起作用，编译器也会尝试改变操作数的顺序，所以也会尝试!(b==a):a!=b,!(b==a)因此，对于TypeA 的a 和TypeB 的b，编译器将能够识别并编译a!= b若需要的话，可以这样做• 一个独立函数operator!• 一个独立函数operator==(TypeA, TypeB)
深入理解Java的垃圾回收机制（GC）实现原理
微笑听雨
05-25 1783
GC是Java虚拟机的重要组成部分，通过自动内存管理，GC提高了Java程序的稳定性和安全性。理解GC的工作原理和不同收集器的特点，有助于选择合适的GC策略，优化应用性能。通过合理配置JVM参数，可以提高GC效率，减少应用停顿时间，提升系统的整体性能。
Spring中有哪些方式可以把bean注入到IOC容器中
06-09
Spring中有以下几种方式可以将Bean注入到IOC容器中： 1. XML配置文件：在XML配置文件中使用<bean>元素来声明Bean，并使用元素来注入依赖项。 2. Java配置类：使用@Configuration注解和@Bean注解来声明Bean，并使用...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值