码迷，mamicode.com
首页 > 编程语言 > 详细

Spring的Bean管理

时间：2020-04-29 21:36:44      阅读：60      评论：0      收藏：0      [点我收藏+]

标签：initial   rod   handler   增强   files   equals   rop   double   repos   

Spring工厂类介绍

Spring工厂类

技术图片

Example

    @Test
    /**
     * 传统方式开发
     */
    public void demo1(){
        //UserService userService = new UserServiceImpl();
        UserServiceImpl userService = new UserServiceImpl();
        //设置属性：
        userService.setName("张三");
        userService.sayHello();
    }

    @Test
    /**
     * Spring的方式实现
     */
    public void demo2(){
        //创建Spring的工厂
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
        //通过工厂获得类
        UserService userService =  (UserService)applicationContext.getBean("userService");
        userService.sayHello();
    }

    @Test
    /**
     * 读取磁盘系统中的配置文件
     */
    public void demo3(){
        //创建Spring的工厂类：
        ApplicationContext applicationContext = new FileSystemXmlApplicationContext("c:\\applicationContext.xml");
        //通过工厂获得类
        UserService userService =  (UserService)applicationContext.getBean("userService");
        userService.sayHello();
    }

    @Test
    /**
     * 传统方式的工厂类：BeanFactory
     */
    public void demo4(){
        //创建工厂类：
        BeanFactory beanFactory = new XmlBeanFactory(new ClassPathResource("applicationContext.xml"));
        //通过工厂获得类：
        UserService userService =  (UserService)beanFactory.getBean("userService");
        userService.sayHello();
    }

    @Test
    /**
     * 传统方式的工厂类：BeanFactory
     */
    public void demo5(){
        //创建工厂类：
        BeanFactory beanFactory = new XmlBeanFactory(new FileSystemResource("c:\\applicationContext.xml"));
        //通过工厂获得类：
        UserService userService =  (UserService)beanFactory.getBean("userService");
        userService.sayHello();
    }

Spring的Bean管理-XML方式（上）

Bean的实例化三种方式

技术图片

方式一

package com.jesse.ioc.demo2;

/**
 * Bean的实例化的三种方式：采用无参数的构造方法的方式
 */
public class Bean1 {
    public Bean1(){
        System.out.println("Bean1被实例化了...");
    }
}

    <!--第一种：无参构造器的方式-->
    <bean id="bean1" class="com.jesse.ioc.demo2.Bean1"/>

    @Test
    public void demo1(){
        //创建工厂
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
        //通过工厂获得类的实例：
        Bean1 bean1 = (Bean1)applicationContext.getBean("bean1");
    }

方式二

package com.jesse.ioc.demo2;

/**
 * Bean的实例化三种方式：静态工厂实例化方式
 */
public class Bean2 {
}

package com.jesse.ioc.demo2;

/**
 * Bean2的静态工厂
 */
public class Bean2Factory {
    public static Bean2 createBean2(){
        System.out.println("Bean2Factory已经执行");
        return new Bean2();
    }
}

    <!--第二种：静态工厂的方式-->
    <bean id="bean2" class="com.jesse.ioc.demo2.Bean2Factory" factory-method="createBean2"/>

    @Test
    public void demo2(){
        //创建工厂
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
        //通过工厂获得类的实例：
        Bean2 bean2 = (Bean2)applicationContext.getBean("bean2");
    }

方式三

package com.jesse.ioc.demo2;

/**
 * Bean的实例化三种方式：实例工厂实例化
 */
public class Bean3 {
}

package com.jesse.ioc.demo2;

public class Bean3Factory {
    public Bean3 createBean3(){
        System.out.println("Bean3Factory执行了...");
        return new Bean3();
    }
}

    <bean id="bean3Factory"  class="com.jesse.ioc.demo2.Bean3Factory"/>
    <bean id="bean3" factory-bean="bean3Factory" factory-method="createBean3"/>

    @Test
    public void demo3(){
        //创建工厂
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
        //通过工厂获得类的实例：
        Bean3 bean3 = (Bean3)applicationContext.getBean("bean3");
    }

Bean的常用配置

技术图片

Bean的作用域

技术图片

Example

package com.jesse.ioc.demo3;

public class Person {
}

    <!--Bean的作用范围-->
    <bean id="person" class="com.jesse.ioc.demo3.Person" scope="prototype"/>

    @Test
    public void demo1() {
        //创建工厂
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
        //通过工厂获得类的实例：
        Person person1 = (Person) applicationContext.getBean("person");
        Person person2 = (Person) applicationContext.getBean("person");

        System.out.println(person1);
        System.out.println(person2);
    }

Bean的生命周期的配置

技术图片

package com.jesse.ioc.demo3;

public class Man {
    public Man(){
        System.out.println("Man被实例化了...");
    }

    public void init(){
        System.out.println("Man被初始化了...");
    }

    public void destory(){
        System.out.println("Man被销毁了...");
    }
}

   <bean id="man" class="com.jesse.ioc.demo3.Man" init-method="init" destroy-method="destory"/>

    @Test
    public void demo2() {
        //创建工厂
        ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
        //通过工厂获得类的实例：
        Man man = (Man) applicationContext.getBean("man");

        System.out.println(man);

        applicationContext.close();
    }

Bean的生命周期的完整过程

技术图片

技术图片

技术图片

package com.jesse.ioc.demo3;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.BeanNameAware;
import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;

public class Man implements BeanNameAware, ApplicationContextAware, InitializingBean, DisposableBean {
    private String name;

    public void setName(String name) {
        System.out.println("第二步：设置属性");
        this.name = name;
    }

    public Man(){
        System.out.println("第一步：初始化...");
    }

    public void init(){
        System.out.println("第七步：Man被初始化了...");
    }

    public void destory(){
        System.out.println("第十一步：Man被销毁了...");
    }

    @Override
    public void setBeanName(String s) {
        System.out.println("第三步：设置Bean的名称" + s);
    }

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        System.out.println("第四步：了解工厂的信息");
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("第六步：属性设置后");
    }

    public void run(){
        System.out.println("第九步：执行业务方法");
    }

    @Override
    public void destroy() throws Exception {
        System.out.println("第十步：执行Spring的销毁方法");
    }
}


package com.jesse.ioc.demo3;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;

public class MyBeanPostProcessor implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object o, String s) throws BeansException {
        System.out.println("第五步：初始化前方法...");
        return o;
    }

    @Override
    public Object postProcessAfterInitialization(Object o, String s) throws BeansException {
        System.out.println("第八步：初始化后方法...");
        return o;
    }
}

    <bean id="man" class="com.jesse.ioc.demo3.Man" init-method="init" destroy-method="destory">
        <property name="name" value="小明"/>
    </bean>

    <bean class="com.jesse.ioc.demo3.MyBeanPostProcessor"/>

    @Test
    public void demo2() {
        //创建工厂
        ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
        //通过工厂获得类的实例：
        Man man = (Man) applicationContext.getBean("man");

        man.run();

        applicationContext.close();
    }

BeanPostProcessor的作用（演示如何增强类方法）

package com.jesse.ioc.demo3;

public interface UseDao {
    public void findAll();

    public void save();

    public void update();

    public void delete();
}


package com.jesse.ioc.demo3;

public class UseDaoImpl implements UseDao {
    @Override
    public void findAll() {
        System.out.println("查询用户...");
    }

    @Override
    public void save() {
        System.out.println("保存用户...");

    }

    @Override
    public void update() {
        System.out.println("修改用户...");

    }

    @Override
    public void delete() {
        System.out.println("删除用户...");

    }
}


package com.jesse.ioc.demo3;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class MyBeanPostProcessor implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        //System.out.println("第五步：初始化前方法...");
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(final Object bean, String beanName) throws BeansException {
        //System.out.println("第八步：初始化后方法啊...");
        if ("useDao".equals(beanName)){
            Object proxy = Proxy.newProxyInstance(bean.getClass().getClassLoader(), bean.getClass().getInterfaces(), new InvocationHandler() {
                @Override
                public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                    if ("save".equals(method.getName())){
                        System.out.println("权限校验==========");
                        return method.invoke(bean,args);
                    }
                    return method.invoke(bean,args);
                }
            });
            return proxy;
        }else {
            return bean;
        }
    }
}


    <bean class="com.jesse.ioc.demo3.MyBeanPostProcessor"/>

    <bean id="useDao" class="com.jesse.ioc.demo3.UseDaoImpl"/>

    @Test
    public void demo3() {
        //创建工厂
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
        //通过工厂获得类的实例：
        UseDao useDao = (UseDao) applicationContext.getBean("useDao");

        useDao.findAll();
        useDao.save();
        useDao.update();
        useDao.delete();

    }

Spring的Bean管理-XML方式（下）

属性注入的方式

技术图片

构造方法的属性注入

技术图片

package com.jesse.ioc.demo4;

public class User {
    private String name;
    private Integer age;

    public User(String name, Integer age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "User{" +
                "name=‘" + name + ‘\‘‘ +
                ", age=" + age +
                ‘}‘;
    }
}


    <!--Bean的构造方法的属性注入-->
    <bean id="user" class="com.jesse.ioc.demo4.User">
        <constructor-arg name="name" value="小明"/>
        <constructor-arg name="age" value="23"/>
    </bean>

    @Test
    public void demo1(){
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
        User user = (User)applicationContext.getBean("user");
        System.out.println(user);
    }

set方法的属性注入

技术图片

package com.jesse.ioc.demo4;

public class Person {
    private String name;
    private Integer age;
    private Cat cat;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

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

    public Cat getCat() {
        return cat;
    }

    public void setCat(Cat cat) {
        this.cat = cat;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name=‘" + name + ‘\‘‘ +
                ", age=" + age +
                ", cat=" + cat +
                ‘}‘;
    }
}


package com.jesse.ioc.demo4;

public class Cat {
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Cat{" +
                "name=‘" + name + ‘\‘‘ +
                ‘}‘;
    }
}


    <!--Bean的set方法的属性注入-->
    <bean id="person" class="com.jesse.ioc.demo4.Person">
        <property name="name" value="李四"/>
        <property name="age" value="32"/>
        <property name="cat" ref="cat"/>
    </bean>

    <bean id="cat" class="com.jesse.ioc.demo4.Cat">
        <property name="name" value="ketty"/>
    </bean>

    @Test
    public void demo2(){
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
        Person person = (Person)applicationContext.getBean("person");
        System.out.println(person);
    }

p名称空间的属性注入

技术图片

       xmlns:p="http://www.springframework.org/schema/p"
    <!--Bean的p名称空间的属性注入-->
    <bean id="person" class="com.jesse.ioc.demo4.Person" p:name="大黄" p:age="34" p:cat-ref="cat"/>

    <bean id="cat" class="com.jesse.ioc.demo4.Cat" p:name="小黄">
    </bean>

SpEL的属性注入

技术图片

package com.jesse.ioc.demo4;

public class Category {
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Category{" +
                "name=‘" + name + ‘\‘‘ +
                ‘}‘;
    }
}

package com.jesse.ioc.demo4;

public class ProductInfo {

    public Double calculatePrice(){
        return Math.random() * 199;
    }
}

package com.jesse.ioc.demo4;

public class Product {
    private String name;
    private Double price;

    private Category category;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Double getPrice() {
        return price;
    }

    public void setPrice(Double price) {
        this.price = price;
    }

    public Category getCategory() {
        return category;
    }

    public void setCategory(Category category) {
        this.category = category;
    }

    @Override
    public String toString() {
        return "Product{" +
                "name=‘" + name + ‘\‘‘ +
                ", price=" + price +
                ", category=" + category +
                ‘}‘;
    }
}

    <!--Bean的SpEL的属性注入-->
    <bean id="category" class="com.jesse.ioc.demo4.Category">
        <property name="name" value="#{‘服装‘}"/>
    </bean>

    <bean id="productInfo" class="com.jesse.ioc.demo4.ProductInfo"/>

    <bean id="product" class="com.jesse.ioc.demo4.Product">
        <property name="name" value="#{‘男装‘}"/>
        <property name="price" value="#{productInfo.calculatePrice()}"/>
        <property name="category" value="#{category}"/>
    </bean>

    @Test
    public void demo3(){
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
        Product product = (Product)applicationContext.getBean("product");
        System.out.println(product);
    }

复杂类型的属性注入

技术图片

package com.jesse.ioc.demo5;

import java.util.*;

public class CollectionBean {
    private String[] arrs; //数组类型
    private List<String> list; //List集合类型
    private Set<String> set; //Set集合类型
    private Map<String,Integer> map; //Map集合类型
    private Properties properties; //属性类型

    public String[] getArrs() {
        return arrs;
    }

    public void setArrs(String[] arrs) {
        this.arrs = arrs;
    }

    public List<String> getList() {
        return list;
    }

    public void setList(List<String> list) {
        this.list = list;
    }

    public Set<String> getSet() {
        return set;
    }

    public void setSet(Set<String> set) {
        this.set = set;
    }

    public Map<String, Integer> getMap() {
        return map;
    }

    public void setMap(Map<String, Integer> map) {
        this.map = map;
    }

    public Properties getProperties() {
        return properties;
    }

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

    @Override
    public String toString() {
        return "CollectionBean{" +
                "arrs=" + Arrays.toString(arrs) +
                ", list=" + list +
                ", set=" + set +
                ", map=" + map +
                ", properties=" + properties +
                ‘}‘;
    }
}


<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:p="http://www.springframework.org/schema/p"
       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">
    <!-- UserService的创建权交给了Spring -->
    <!--<bean id="userService" class="com.jesse.ioc.demo1.UserServiceImpl">
        &lt;!&ndash;设置属性&ndash;&gt;
        <property name="name" value="李四"/>
    </bean>-->

    <!--Bean的实例化的三种方式-->
    <!--第一种：无参构造器的方式-->
    <!--<bean id="bean1" class="com.jesse.ioc.demo2.Bean1"/>-->
    <!--第二种：静态工厂的方式-->
    <!--<bean id="bean2" class="com.jesse.ioc.demo2.Bean2Factory" factory-method="createBean2"/>-->
    <!--第二种：实例工厂的方式-->
    <!--<bean id="bean3Factory"  class="com.jesse.ioc.demo2.Bean3Factory"/>
    <bean id="bean3" factory-bean="bean3Factory" factory-method="createBean3"/>-->

    <!--Bean的作用范围-->
    <!--<bean id="person" class="com.jesse.ioc.demo3.Person" scope="prototype"/>-->

    <!--<bean id="man" class="com.jesse.ioc.demo3.Man" init-method="init" destroy-method="destory">
        <property name="name" value="小明"/>
    </bean>-->

    <!--<bean class="com.jesse.ioc.demo3.MyBeanPostProcessor"/>

    <bean id="useDao" class="com.jesse.ioc.demo3.UseDaoImpl"/>-->

    <!--Bean的构造方法的属性注入-->
    <!--<bean id="user" class="com.jesse.ioc.demo4.User">
        <constructor-arg name="name" value="小明"/>
        <constructor-arg name="age" value="23"/>
    </bean>-->

    <!--Bean的set方法的属性注入-->
    <!--<bean id="person" class="com.jesse.ioc.demo4.Person">
        <property name="name" value="李四"/>
        <property name="age" value="32"/>
        <property name="cat" ref="cat"/>
    </bean>

    <bean id="cat" class="com.jesse.ioc.demo4.Cat">
        <property name="name" value="ketty"/>
    </bean>-->

    <!--Bean的p名称空间的属性注入-->
    <bean id="person" class="com.jesse.ioc.demo4.Person" p:name="大黄" p:age="34" p:cat-ref="cat"/>

    <bean id="cat" class="com.jesse.ioc.demo4.Cat" p:name="小黄">
    </bean>

    <!--Bean的SpEL的属性注入-->
    <bean id="category" class="com.jesse.ioc.demo4.Category">
        <property name="name" value="#{‘服装‘}"/>
    </bean>

    <bean id="productInfo" class="com.jesse.ioc.demo4.ProductInfo"/>

    <bean id="product" class="com.jesse.ioc.demo4.Product">
        <property name="name" value="#{‘男装‘}"/>
        <property name="price" value="#{productInfo.calculatePrice()}"/>
        <property name="category" value="#{category}"/>
    </bean>

    <!--集合类型的属性注入-->
    <bean id="collectionBean" class="com.jesse.ioc.demo5.CollectionBean">
        <!--数组类型-->
        <property name="arrs">
            <list>
                <value>aaa</value>
                <value>bbb</value>
                <value>ccc</value>
            </list>
        </property>
        <!--List集合的属性注入-->
        <property name="list">
            <list>
                <value>111</value>
                <value>222</value>
                <value>333</value>
            </list>
        </property>
        <!--Set集合的属性注入-->
        <property name="set">
            <set>
                <value>ddd</value>
                <value>eee</value>
                <value>fff</value>
            </set>
        </property>
        <!--Map集合的属性注入-->
        <property name="map">
            <map>
                <entry key="aaa" value="111"/>
                <entry key="bbb" value="222"/>
                <entry key="ccc" value="333"/>
            </map>
        </property>
        <!--Properties的属性注入-->
        <property name="properties">
            <props>
                <prop key="username">root</prop>
                <prop key="password">1234</prop>
            </props>
        </property>
    </bean>
</beans>

package com.jesse.ioc.demo5;

import com.jesse.ioc.demo4.Person;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class SpringDemo5 {
    @Test
    public void demo1(){
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
        CollectionBean collectionBean = (CollectionBean)applicationContext.getBean("collectionBean");
        System.out.println(collectionBean);
    }
}

Spring的Bean管理-注解方式

Bean的管理

技术图片

package com.jesse.demo1;

import org.springframework.stereotype.Component;
import org.springframework.stereotype.Service;

/**
 * Spring的Bean管理的注解方式：
 */
//@Component("userService")
@Service("userService")
public class UserService {
    public String sayHello(String name){
        return "Hello" + name;
    }
}


<?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" xsi:schemaLocation="
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">

    <!--开启注解扫描-->
    <context:component-scan base-package="com.jesse.demo1"/>
</beans>

package com.jesse.demo1;

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

public class SpringDemo1 {

    @Test
    public void demo1(){
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");

        UserService userService = (UserService) applicationContext.getBean("userService");

        String s = userService.sayHello("张三");

        System.out.println(s);
    }
}

属性注入的注解

技术图片

技术图片

package com.jesse.demo1;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;

/**
 * Spring的Bean管理的注解方式：
 */
//@Component("userService")
@Service("userService")
public class UserService {
    @Value("米饭")
    private String something;
/*    @Autowired
    @Qualifier("userDao")*/
    @Resource(name = "userDao")
    private UserDao userDao;

    public String sayHello(String name){
        return "Hello" + name;
    }

    public void eat(){
        System.out.println("eat:"+something);
    }

    public void save(){
        System.out.println("Service中保存用户...");
        userDao.save();
    }
}


package com.jesse.demo1;

import org.springframework.stereotype.Repository;

@Repository("userDao")
public class UserDao {

    public void save(){
        System.out.println("DAO中保存用户...");
    }
}


<?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" xsi:schemaLocation="
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">

    <!--开启注解扫描-->
    <context:component-scan base-package="com.jesse.demo1"/>
</beans>

    @Test
    public void demo3(){
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");

        UserService userService = (UserService) applicationContext.getBean("userService");

        userService.save();
    }

其他注解

@PostConstruct和@PreDestory

技术图片

package com.jesse.demo2;

import org.springframework.stereotype.Component;

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

@Component("bean1")
public class Bean1 {

    @PostConstruct
    public void init(){
        System.out.println("initBean...");
    }

    public void say(){
        System.out.println("say....");
    }

    @PreDestroy
    public void destory(){
        System.out.println("destoryBean...");
    }
}


    @Test
    public void demo1(){
        ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");

        Bean1 bean1 = (Bean1) applicationContext.getBean("bean1");

        bean1.say();

        applicationContext.close();
    }

@Scope

技术图片

package com.jesse.demo2;

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

@Component("bean2")
@Scope("prototype")
public class Bean2 {
}


    @Test
    public void demo2(){
        ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");

        Bean2 bean1 = (Bean2) applicationContext.getBean("bean2");
        Bean2 bean2 = (Bean2) applicationContext.getBean("bean2");

        System.out.println(bean1 == bean2);
    }

Spring的XML和注解整合开发

技术图片

package com.jesse.demo3;

public class CategoryDao {
    public void save(){
        System.out.println("CategoryDao中的save方法执行了...");
    }
}

package com.jesse.demo3;

public class ProductDao {
    public void save(){
        System.out.println("ProductDao的save方法执行了...");
    }
}

package com.jesse.demo3;

import javax.annotation.Resource;

public class ProductService {
    @Resource(name = "categoryDao")
    private CategoryDao categoryDao;
    @Resource(name = "productDao")
    private ProductDao productDao;

/*    public void setCategoryDao(CategoryDao categoryDao) {
        this.categoryDao = categoryDao;
    }

    public void setProductDao(ProductDao productDao) {
        this.productDao = productDao;
    }*/

    public void save(){
        System.out.println("ProductService的save方法执行了...");
        categoryDao.save();
        productDao.save();
    }
}


<?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" xsi:schemaLocation="
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">

    <!--开启注解扫描-->
<!--    <context:component-scan base-package="com.jesse"/>-->
    <context:annotation-config/>
    <bean id="productService" class="com.jesse.demo3.ProductService">
        <!--<property name="productDao" ref="productDao"/>
        <property name="categoryDao" ref="categoryDao"/>-->
    </bean>

    <bean id="productDao" class="com.jesse.demo3.ProductDao"/>

    <bean id="categoryDao" class="com.jesse.demo3.CategoryDao"/>
</beans>

package com.jesse.demo3;

import com.jesse.demo2.Bean2;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class SpringDemo3 {

    @Test
    public void demo1(){
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");

        ProductService productService = (ProductService)applicationContext.getBean("productService");

        productService.save();
    }
}

Spring的Bean管理

标签：initial   rod   handler   增强   files   equals   rop   double   repos   

原文地址：https://www.cnblogs.com/jessekkk/p/12804876.html
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！