精华内容
下载资源
问答
  • 在装配对象的时候,将Spring中定义的对象注入到配置文件属性中 (3)IOC与DI的关系 实现IOC思想需要DI做支持 (4)IOC与DI的区别 IOC 和 DI 两者的本质是一样的,都是为了降低组件和组件间的耦合性 描述角度不同 IOC:组件...

    1.IOC和DI

    (1)IOC(Inversion of Control) 控制反转

    产生对象的控制权从调用者本身(程序代码)转移到外部容器(xml配置文件) ,组件之间耦合性降低

    (2)DI(Dependency Injection) 依赖注入

    在装配对象的时候,将Spring中定义的对象注入到配置文件属性中

    (3)IOC与DI的关系

    实现IOC思想需要DI做支持

    (4)IOC与DI的区别

    • IOC 和 DI 两者的本质是一样的,都是为了降低组件和组件间的耦合性
    • 描述角度不同
    • IOC:组件是如何产生的
    • DI:组件是由其他不同的组件所组装起来

    2.Spring Bean运用XML文件的几种注入方式

    用于下面几种注入方式的公共Bean层,DAO层及Spring配置

    User类

    	public class User {
        	private Integer id;
        	private String username;
    	   	private String password;
    
        	public Integer getId() {
            	return id;
        	}
    
    	   	 public void setId(Integer id) {
            	this.id = id;
        	}
    
        	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 User() {
        	}
    		
        	public User(Integer id, String username, String password) {
            	this.id = id;
            	this.username = username;
            	this.password = password;
        	}
    	}
    

    IUserDao接口类

    	void insert();
    	void setUserDao(IUserDao userDao);
    

    MySqlDaoImpl实现类

    	public void insert() {
            System.out.println("往Mysql添加一条记录");
        }
    

    OracleDaoImpl实现类

    	public void insert() {
            System.out.println("往Oracle添加一条记录");
        }
    

    spring.xml配置文件
    如何生成可查看我之前写的[IDEA运用Maven项目搭建Spring]

    	<!--以下依赖注入后统一由Spring容器管理-->
    	<!--依赖注入MySqlDao的实现类-->
        <bean id="mySqlDao" class="com.cx.dao.impl.MySqlDaoImpl"/>
        
        <!--依赖注入OracleDao的实现类-->
        <bean id="oracleDao" class="com.cx.dao.impl.OracleDaoImpl"/>
    

    (1)SET属性注入

    ①Service层

    IUserService接口类

    	void UserAdd();
    

    UserServiceImpl实现类

    	/**
         * Dao层调用
         */ 
        IUserDao userDao;
    
        /**
         * 不添加SET方法的话,Spring配置文件配置完测试时会空指针异常
         *
         * @param userDao
         */
        public void setUserDao(IUserDao userDao) {
            this.userDao = userDao;
        }
    
        public void UserAdd() {
            userDao.insert();
        }
    
    ②Spring配置文件
        <!--SET属性注入方式-->
        <bean id="userService" class="com.cx.service.impl.UserServiceImpl">
            <property name="userDao" ref="oracleDao"/>
        </bean>
    
    ③测试
    	@Test
        public void userServiceTest() {
            ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring.xml");
            IUserService userService = (IUserService)applicationContext.getBean("userService");
            userService.UserAdd();
        }
    
    ④特点
    • 只要修改Spring配置文件中的userService的ref引用,就可以切换不同的Dao层实现类,从而不动源程序代码

    (2)构造器注入

    ①Bean层

    注: 一定要有构造方法

    ②Spring配置文件
    	<!--构造器注入-->
        <bean id="user" class="com.cx.bean.User">
            <constructor-arg name="id" value="1"/>
            <constructor-arg name="username" value="李四"/>
            <constructor-arg name="password" value="123"/>
        </bean>
    
    ③测试
    @Test
        public void userTest() {
            ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring.xml");
            User user = (User)applicationContext.getBean("user");
            System.out.println(user);
        }
    

    (3)动态工厂注入

    ①Service层与SET注入方式内容相同
    ②创建ServiceFactory工厂类来获取UserService实现类
    	public IUserService getUserService() {
            return new UserServiceImpl();
        }
    
    ③Spring配置文件
    	<!--动态工厂注入-->
    	<!--依赖注入ServiceFactory工厂类-->
        <bean id="factory" class="com.cx.factory.ServiceFactory"/>
        
        <bean id="userServiceFactory" factory-bean="factory" factory-method="getUserService">
            <property name="userDao" ref="oracleDao"/>
        </bean>
    
    ④测试
    	@Test
        public void userServiceTest2() {
            ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring.xml");
            IUserService userService = (IUserService)applicationContext.getBean("userServiceFactory");
            userService.UserAdd();
        }
    
    ⑤特点
    • 可以根据工厂模式来获取实现类

    (4)静态工厂注入

    ①Service层与SET注入方式内容相同
    ②创建ServiceStaticFactory工厂类来获取UserService实现类
    	public static IUserService getUserService() {
            return new UserServiceImpl();
        }
    

    与动态工厂注入不同,此处添加了static

    ③Spring配置文件
    	<!--静态工厂注入-->
        <bean id="userServiceStaticFactory" class="com.cx.factory.ServiceStaticFactory" factory-method="getUserService">
            <property name="userDao" ref="mySqlDao"/>
        </bean>
    

    比动态工厂注入方式少了个bean

    ④测试
    	@Test
        public void userServiceTest3() {
            ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring.xml");
            IUserService userService = (IUserService)applicationContext.getBean("userServiceStaticFactory");
            userService.UserAdd();
        }
    

    (5)c命名空间注入

    ①在Spring配置文件的Beans中添加
    	xmlns:c="http://www.springframework.org/schema/c"
    
    ②Spring配置文件
    	<bean id="cUser" class="com.cx.bean.User" c:id="1" c:username="王五" c:password="222"/>
    
    ③测试
    	@Test
        public void userTest3() {
            ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring.xml");
            User user = (User)applicationContext.getBean("cUser");
            System.out.println(user);
        }
    
    ④目的
    • 简化构造器注入内容

    (6)p命名空间注入

    ①在Spring配置文件的Beans中添加
    	xmlns:p="http://www.springframework.org/schema/p"
    
    ②Spring配置文件
    	<bean id="pUser" class="com.cx.bean.User" p:id="2" p:username="赵六" p:password="333"/>
    
    ③测试
    	@Test
        public void userTest4() {
            ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring.xml");
            User user = (User)applicationContext.getBean("pUser");
            System.out.println(user);
        }
    
    ④目的
    • 简化SET属性注入内容
    展开全文
  • 尽管Spring长期以来确实与...不过,鉴于已经存在那么多基于XMLSpring配置,所以理解如何在Spring中使用XML还是很重要的。但是,我希望本节的内容只是用来帮助你维护已有的XML配置,在完成新的Spring工作时,希望你...

    尽管Spring长期以来确实与XML有着关联,但现在需要明确的是,XML不再是配置Spring的唯一可选方案。Spring现在有了强大的自动化配置和基于Java的配置,XML不应该再是你的第一选择了。不过,鉴于已经存在那么多基于XML的Spring配置,所以理解如何在Spring中使用XML还是很重要的。但是,我希望本节的内容只是用来帮助你维护已有的XML配置,在完成新的Spring工作时,希望你会使用自动化配置和JavaConfig。

    1.1创建XML配置规范

    在使用XML为Spring装配bean之前,你需要创建一个新的配置规范。在使用JavaConfig的时候,这意味着要创建一个带有@Configuration注解的类,而在XML配置中,这意味着要创建一个XML文件,并且要以元素为根。

    44692f0a853a8150541e3073ce92d695.png

    很容易就能看出来,这个基本的XML配置已经比同等功能的JavaConfig类复杂得多了。作为起步,在JavaConfig中所需要的只是@Configuration,但在使用XML时,需要在配置文件的顶部声明多个XML模式(XSD)文件,这些文件定义了配置Spring的XML元素。借助Spring Tool Suite创建XML配置文件创建和管理Spring XML配置文件的一种简便方式是使用Spring ToolSuite(https://spring.io/tools/sts)。在Spring Tool Suite的菜单中,选择File>New>Spring Bean Configuration File,能够创建SpringXML配置文件,并且可以选择可用的配置命名空间。

    1.2声明一个简单的

    要在基于XML的Spring配置中声明一个bean,我们要使用spring-beans模式中的另外一个元素:。元素类似于JavaConfig中的@Bean注解。我们可以按照如下的方式声明CompactDiscbean:

    6a1d46309946690a167ea4b1b2e400ce.png

    这里声明了一个很简单的bean,创建这个bean的类通过class属性来指定的,并且要使用全限定的类名。因为没有明确给定ID,所以这个bean将会根据全限定类名来进行命名。在本例中,bean的ID将会是“soundsystem.SgtPeppers#0”。其中,“#0”是一个计数的形式,用来区分相同类型的其他bean。如果你声明了另外一个SgtPeppers,并且没有明确进行标识,那么它自动得到的ID将会是“soundsystem.SgtPeppers#1”。尽管自动化的bean命名方式非常方便,但如果你要稍后引用它的话,那自动产生的名字就没有多大的用处了。因此,通常来讲更好的办法是借助id属性,为每个bean设置一个你自己选择的名字:

    bc34b0bb6682bf3fde6960a3cf90d99f.png

    1.3借助构造器注入初始化bean

    在Spring XML配置中,只有一种声明bean的方式:使用元素并指定class属性。Spring会从这里获取必要的信息来创建bean。但是,在XML中声明DI时,会有多种可选的配置方案和风格。具体到

    构造器注入,有两种基本的配置方案可供选择:

    04285ac641c4442a23d2b8439d8ccd04.png

    构造器注入bean引用按照现在的定义,CDPlayerbean有一个接受CompactDisc类型的构造器。这样,我们就有了一个很好的场景来学习如何注入bean的引用。现在已经声明了SgtPeppers bean,并且SgtPeppers类实现了CompactDisc接口,所以实际上我们已经有了一个可以注入到CDPlayerbean中的bean。我们所需要做的就是在XML中声明CDPlayer并通过ID引用SgtPeppers:

    9809553bcb5d92797b3ed9c2ec86cb6d.png

    当Spring遇到这个元素时,它会创建一个CDPlayer实例。元素会告知Spring要将一个ID为compactDisc的bean引用传递到CDPlayer的构造器中。

    作为替代的方案,你也可以使用Spring的c-命名空间。c-命名空间是在Spring 3.0中引入的,它是在XML中更为简洁地描述构造器参数的方式。要使用它的话,必须要在XML的顶部声明其模式,如下所示

    2c2647063b0e9ef9a3fa253e0f1aaff4.png

    在c-命名空间和模式声明之后,我们就可以使用它来声明构造器参数

    了,如下所示:

    9015e06610189552b7ae5234f9744e92.png

    迄今为止,我们所做的DI通常指的都是类型的装配——也就是将对象的引用装配到依赖于它们的其他对象之中——而有时候,我们需要做的只是用一个字面量值来配置对象。为了阐述这一点,假设你要创建CompactDisc的一个新实现,如下所示:

    93cfb77f791f09f2ec713daea5865c88.png

    在SgtPeppers中,唱片名称和艺术家的名字都是硬编码的,但是这个CompactDisc实现与之不同,它更加灵活。像现实中的空磁盘一样,它可以设置成任意你想要的艺术家和唱片名。现在,我们可以将

    已有的SgtPeppers替换为这个类:

    dba3fc14e1d6aebc50f40e88da576acf.png

    我们再次使用元素进行构造器参数的注入。但是这一次我们没有使用“ref”属性来引用其他的bean,而是使用了value属性,通过该属性表明给定的值要以字面量的形式注入到构造器之中。如果要使用c-命名空间的话,这个例子又该是什么样子呢?第一种方案是引用构造器参数的名字:

    21da7c7df879c1eef5aadfb3dce525e3.png

    在装配bean引用和字面量值方面,和c-命名空间的功能是相同的。但是有一种情况是能够实现,c-命名空间却无法做到的。接下来,让我们看一下如何将集合

    装配到构造器参数中。

    02dffadeddf2872c8948bc20b263bff1.png

    首先,可以使用元素将其声明为一个列表

    60f0fd8a6a08146b106266b3cd473d26.png

    当list中元素是引用类型时

    d0f1a9565e08f9fcadadc6bc1ac820c6.png

    1.4设置属性

    到目前为止,CDPlayer和BlankDisc类完全是通过构造器注入的,没有使用属性的Setter方法。接下来,我们就看一下如何使用Spring XML实现属性注入。假设属性注入的CDPlayer如下所示:

    9129088764691ca8f9eed541bb5a592e.png

    a9684654a9757297152f7627162711d2.png

    元素为属性的Setter方法所提供的功能与元素为构造器所提供的功能是一样的。在本例中,它引用了ID为compactDisc的bean(通过ref属性),并将其注入到compactDisc属性中(通过setCompactDisc()方法)。如果你现在运行测试的话,它应该就能通过了。

    我们已经知道,Spring为元素提供了c-命名空间作为替代方案,与之类似,Spring提供了更加简洁的p-命名空间,作为元素的替代方案。为了启用p-命名空间,必须要在XML文件中与其他的命名空间一起对其进行声明:

    0d1f615a9f6750c8d375c8f6c35250a2.png

    我们可以使用p-命名空间,按照以下的方式装配compactDisc属性

    20e4acbb90027f162729d73a3eb9dd59.png

    不过,BlankDisc这次完全通过属性

    注入进行配置,而不是构造器注入。新的BlankDisc类如下所示:

    4349d0b01e344901718a730b79f1735e.png

    fbc5e926a0e48f5fe18272d5d8eb5408.png

    展开全文
  • Spring注入的作用是为了解决实现接口类当中可以调用其他类当中的对象以及方法,并且不是硬编码的方式,而是通过获取核心容器对象方式创建新的对象。例如下面我可以通过UserServiceimpl调用dao对象。 1.构造函数...

    目录

     1.构造函数方式注入

    这里是主函数

    这里是applicationContext.xml主配置文件

    真正的Dao层的实现代码UserServiceImpl实现类

    2.(1)set方法注入(常用)applicationContext.xml(注入一般类型,引用类型)

     UserServiceImpl3实现类

    主函数调用

     2.(2)set方法注入(常用)applicationContext.xml(注入集合类型,大致可以记为list集合和Map集合)

    main方法

    UserServiceImpl4实现类


    Spring注入的作用是为了解决实现接口类当中可以调用其他类当中的对象以及方法,并且不是硬编码的方式,而是通过获取核心容器对象方式创建新的对象。例如下面我可以通过UserServiceimpl调用dao对象。

     1.构造函数方式注入

    这里是主函数

        
    public static void main(String[] args) {
    		// 1. 获取核心容器对象
    		ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
                    // 1.(1)构造方法注入,传递一个dao对象
    		IUserService service =  context.getBean("userService",IUserService.class);
    		
    	}

    这里是applicationContext.xml主配置文件

    <!-- 1.(1)构造方法注入,传递一个dao对象 -->
    	<bean id="userService"
    		class="com.bookmanagesystem.service.impl.UserServiceImpl">
    		<constructor-arg name="dao" ref="userDao"></constructor-arg>
                    <!-- 实际上是等同于创建了一个new UserServiceImpl(dao) -->
    	</bean>
    
    	<bean id="userDao"
    		class="com.bookmanagesystem.dao.impl.UserDaoImpl">
    	</bean>

    真正的Dao层的实现代码UserServiceImpl实现类

    // 真正的操作由Dao层执行
    	private IUserDao dao ;
    	public UserServiceImpl(IUserDao dao) {
    		super();
    		//System.out.println(dao.queryUser());
    		this.dao = dao;
    	}
    	
    
    	public IUserDao getDao() {
    		return dao;
    	}
    	public void setDao(IUserDao dao) {
    		this.dao = dao;                                                                
    	}

    2.(1)set方法注入(常用)applicationContext.xml(注入一般类型,引用类型)

    <!-- 1.(2)set方法注入,传递多个参数 -->
    	<bean id="userService3"
    		class="com.bookmanagesystem.service.impl.UserServiceImpl3">
    		<property name="name" value="方国城"></property>
    		<property name="age" value="99"></property>
    		<property name="birth" ref="birthday2"></property>
    
    	</bean>
    	<bean id="birthday2" class="java.util.Date"></bean>

     UserServiceImpl3实现类

    public class UserServiceImpl3 implements IUserService{
    
    	private String name;
    	private int age;
    	private Date birth;
    	
    	
    	public String getName() {
    		return name;
    	}
    
    	public void setName(String name) {
    		this.name = name;
    	}
    
    	public int getAge() {
    		return age;
    	}
    
    	public void setAge(int age) {
    		this.age = age;
    	}
    
    	public Date getBirth() {
    		return birth;
    	}
    
    	public void setBirth(Date birth) {
    		this.birth = birth;
    	}
    
    	@Override
    	public String toString() {
    		return "UserServiceImpl3 [name=" + name + ", age=" + age + ", birth=" + birth + "]";
    	}
    
    	@Override
    	public String queryUser() {
    		// TODO Auto-generated method stub
    		return "";
    	}
    	
    
    
    	
    }

    主函数调用

    public static void main(String[] args) {
    		// 1. 获取核心容器对象
    		ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
    
    		// 2. 根据id获取bean对象的两种方法
    		//2.set方法注入,传递多个参数
    		IUserService service3 = (IUserService) context.getBean("userService3");
    		System.out.println(service3);
    		// 3.关闭容器(如果不记得关闭容器,最典型的问题就是数据库连接不能释放)
    		((ClassPathXmlApplicationContext) context).close();
    
    	}

     2.(2)set方法注入(常用)applicationContext.xml(注入集合类型,大致可以记为list集合和Map集合)

    <!-- 2.(1)set方法注入,传递集合 list map -->
    	<bean id="userService4"
    		class="com.bookmanagesystem.service.impl.UserServiceImpl4">
    		<property name="strings">
    			<array>
    				<value> zhangsan</value>
    				<value> lisi</value>
    				<value> wangwu</value>
    			</array>
    		</property>
    		<property name="list">
    			<list>
    				<value> zhangsan</value>
    				<value> lisi</value>
    				<value> 方国城</value>
    			</list>
    		</property>
    		<property name="set">
    			<set>
    				<value> zhangsan</value>
    				<value> lisi</value>
    				<value> 方国城</value>
    			</set>
    		</property>
    	<property name="map">
    		<map>
    			<entry key="string" value="shabi"></entry>
    			<entry key="string1" value="shabi1"></entry>
    			<entry key="string2" value="shabi2"></entry>
    		</map>
    	</property>
    	<property name="properties">
    		<props>
    			<prop key="driver">sajfaskasjn </prop>
    			<prop key="url">https:://www.baidu.conima </prop>
    			<prop key="username">root </prop>
    			<prop key="password">root </prop>
    		</props>
    	</property>
    	</bean>

    main方法

    public static void main(String[] args) {
    		// 1. 获取核心容器对象
    		ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
    
    		// 2. 根据id获取bean对象的两种方法
    		// 1.(1)构造方法注入,传递一个dao对象
    		IUserService service = (IUserService) context.getBean("userService");
    		//2.set方法注入,传递集合
    		IUserService service4 = (IUserService) context.getBean("userService4");
    		service4.queryUser();
    		// 3.关闭容器(如果不记得关闭容器,最典型的问题就是数据库连接不能释放)
    		((ClassPathXmlApplicationContext) context).close();
    
    	}

    UserServiceImpl4实现类

    public class UserServiceImpl4 implements IUserService{
    
    	private String[] strings;
    	private List<String> list;
    	private Set<String> set;
    	private Map< String, String> map;
    	private Properties properties;
    	
    	public void setStrings(String[] strings) {
    		this.strings = strings;
    	}
    
    	public void setList(List<String> list) {
    		this.list = list;
    	}
    
    	public void setSet(Set<String> set) {
    		this.set = set;
    	}
    
    	public void setMap(Map<String, String> map) {
    		this.map = map;
    	}
    
    	public void setProperties(Properties properties) {
    		this.properties = properties;
    	}
    
    	public String[] getStrings() {
    		return strings;
    	}
    
    	public List<String> getList() {
    		return list;
    	}
    
    	public Set<String> getSet() {
    		return set;
    	}
    
    	public Map<String, String> getMap() {
    		return map;
    	}
    
    	public Properties getProperties() {
    		return properties;
    	}
    
    
    
    	@Override
    	public String toString() {
    		return "UserServiceImpl4 [strings=" + Arrays.toString(strings) + ", list=" + list + ", set=" + set + ", map="
    				+ map + ", properties=" + properties + "]";
    	}
    
    	@Override
    	public String queryUser() {
    	  System.out.println(Arrays.toString(strings));
    	  System.out.println(list);
    	  System.out.println(set);
    	  System.out.println(map);
    	  System.out.println(properties);
    		return "";
    	}
    	
    
    
    	
    }
    



     

    展开全文
  • Spring容器支持多种形式的 Bean 的装配方式,如基于 XMLBean 装配、基于 Annotation 的 Bean 装配和自动装配等。 Spring 基于 XML 的装配通常采用两种实现方式,即set注入和构造注入。 1、set注入 在 ...

    一、Bean 的装配

           Bean 的装配可以理解为依赖关系注入,Bean 的装配方式也就是 Bean 的依赖注入方式。Spring容器支持多种形式的 Bean 的装配方式,如基于 XML 的 Bean 装配、基于 Annotation 的 Bean 装配和自动装配等。

           Spring 基于 XML 的装配通常采用两种实现方式,即set注入和构造注入。

    1、set注入

           在 Spring 实例化 Bean 的过程中,首先会调用默认的构造方法实例化 Bean 对象,然后通过Java的反射机制调用 setXxx() 方法进行属性的注入。因此,设值注入要求一个 Bean 的对应类必须满足以下两点要求:

    • 必须提供一个默认的无参构造方法。
    • 必须为需要注入的属性提供对应的 setter 方法。

           接下来就用一个简单案例演示一下set注入。步骤如下:

           (1)创建Person类,并提供私有属性name和age以及它们的set方法,覆写toString()。

    public class Person {
        private String name;
        private Integer age;
    
        public void setName(String name) {
            this.name = name;
        }
    
        public void setAge(Integer age) {
            this.age = age;
        }
    
        @Override
        public String toString() {
            return "Person{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }
    }
    

           (2)在bean.xml文件中配置person对象,用set注入方式注入属性值。

        <!--  配置Person  -->
        <bean id="person" class="com.yht.example1.entity.Person">
            <!--  name:类中属性的名称  value:向属性注入的值     -->
            <property name="name" value="张三"></property>
            <property name="age" value="33"></property>
         </bean>

           (3)进行单元测试

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

            执行结果如下:

    2、构造注入

           使用设值注入时,在 Spring 配置文件中,需要使用 <bean> 元素的子元素 <property> 元素为每个属性注入值。而使用构造注入时,在配置文件中,主要使用 <constructor-arg> 标签定义构造方法的参数,可以使用其 value 属性(或子元素)设置该参数的值。下面通过案例演示基于 XML 方式的 Bean 的装配。

           构造注入有两种方式:第一种通过 <constructor-arg>的子元素name完成;第二种通过 <constructor-arg>的子元素index来完成,这里的index指的是属性在构造方法中的下标,从0开始。来做一个简单测试:

           (1)创建Book类,提供私有属性bName和bAuthor,并提供有参构造(bName和bAuthor)。

    public class Book {
        private String bName;
        private String bAuthor;
    
        public Book(String bName, String bAuthor) {
            this.bName = bName;
            this.bAuthor = bAuthor;
        }
    
        @Override
        public String toString() {
            return "Book{" +
                    "bName='" + bName + '\'' +
                    ", bAuthor='" + bAuthor + '\'' +
                    '}';
        }
    }
    

           (2)在bean.xml中配置person对象,用构造注入的方式注入属性值。

        <!-- 配置book:用name的方式   -->
        <bean id="book1" class="com.yht.example1.entity.Book">
            <constructor-arg name="bName" value="三国演义"></constructor-arg>
            <constructor-arg name="bAuthor" value="罗贯中"></constructor-arg>
        </bean>
        <!-- 配置book:用index的方式   -->
        <bean id="book2" class="com.yht.example1.entity.Book">
            <constructor-arg name="bName" value="水浒传"></constructor-arg>
            <constructor-arg name="bAuthor" value="施耐庵"></constructor-arg>
        </bean>

           (3)进行单元测试。

        @Test
        public void testBook(){
            ApplicationContext applicationContext = new ClassPathXmlApplicationContext("bean.xml");
            //获取用name注入的对象
            Book book1 = (Book) applicationContext.getBean("book1");
            System.out.println(book1);
            //获取用index注入的对象
            Book book2 = (Book) applicationContext.getBean("book2");
            System.out.println(book2);
        }

            执行结果如下:

    3、p名称空间注入

    从 2.0开始,Spring支持使用名称空间的可扩展配置格式。这些名称空间都是基于一种XML Schema定义。事实上,我们所看到的所有bean的配置格式都是基于一个 XML Schema文档。

    p名称空间并不需要定义在一个XSD文件中,它只在Spring内核中存在采用p名称空间就可以在bean元素中使用属性来描述property的值。

    写法:

    普通属性        p:属性名=”值”

    对象属性        p:属性名-ref=”值”

    注意事项:

    P名称空间注入走的也是set方法,官方目的是简化set注入的property标签的写法,所以并不适用于构造注入。

           我们以注入Person对象的属性值为例,步骤如下:

           (1)在bean.xml中导入p名称空间。

    xmlns:p="http://www.springframework.org/schema/p"

            (2)配置person对象,注入属性。

        <!-- p名称空间注入   -->
        <bean id="person2" class="com.yht.example1.entity.Person" p:name="李四" p:age="24" >
        </bean>

           (3)进行单元测试。

        @Test
        public void testPerson(){
            ApplicationContext applicationContext = new ClassPathXmlApplicationContext("bean1.xml");
            //set注入
            Person person = (Person) applicationContext.getBean("person");
            System.out.println(person);
            //p名称空间注入
            Person person2 = (Person) applicationContext.getBean("person2");
            System.out.println(person2);
        }

            执行结果如下:

    二、Bean装配的几点说明

    1、bean的子元素name

           bean除了id和class属性,还有一个name属性,Spring 容器可以通过此属性对容器中的 Bean 进行配置和管理,name 属性中可以为 Bean 指定多个名称,每个名称之间用逗号或分号隔开,且可以包含特殊字符。我们用案例来验证一下:

           (1)在bean.xml配置person对象,并给定多个值。

    <!--  测试bean的name属性  -->
        <bean class="com.yht.example1.entity.Person" name="p1,p2,p3@">
            <property name="name" value="赵飞"></property>
            <property name="age" value="23"></property>
        </bean>

           (2)进行单元测试。

        @Test
        public void testPersonP(){
            ApplicationContext applicationContext = new ClassPathXmlApplicationContext("bean1.xml");
            Person p1 = (Person) applicationContext.getBean("p1");
            System.out.println(p1);
            Person p2 = (Person) applicationContext.getBean("p2");
            System.out.println(p2);
            Person p3 = (Person) applicationContext.getBean("p3@");//含有特殊字符
            System.out.println(p3);
        }

           执行结果如下:

           注意点:不管是id还是name,其值都不能重复。即:id之间、name之间、id和name之间都必须唯一。如下:

    2、set注入和构造注入是否可以混合使用

           (1)对Person类做一些修改,添加无参构造、含有name的有参构造。

    public class Person {
        private String name;
        private Integer age;
    
        public Person() {
        }
    
        public Person(String name) {
            this.name = name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public void setAge(Integer age) {
            this.age = age;
        }
    
        @Override
        public String toString() {
            return "Person{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }
    }
    

           (2)在bean.xml中配置Person对象,注入属性

        <!--set注入和构造注入混合使用-->
        <bean id="per" class="com.yht.example1.entity.Person">
            <constructor-arg name="name" value="tom"></constructor-arg>
            <property name="age" value="41"></property>
        </bean>

           (3)进行单元测试。

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

           执行结果如下:

           结论:set注入和构造注入可以同时使用,但不推荐。 

    展开全文
  • 点击关注公众号,利用碎片时间学习通过注解注入Bean背景我们谈到Spring的时候一定会提到IOC容器、DI依赖注入,Spring通过将一个个类标注为Bean的方法注入到IOC容器中,达到...
  • spring元素用来存储多个键值对属性,类型为Java.util.Map;他的子标签用来定义Map中的键值实体,下面举例说明;Article.java这个articleclass有一个属性是作者联名信息,使用序号和作者名来构成一个Map属性.importjava....
  • Spring基于XML装配Bean

    2021-03-18 12:38:02
    Spring 容器支持多种形式的 Bean 的装配方式,如基于 XMLBean 装配、基于 Annotation 的 Bean 装配和自动装配等。 Spring 基于 XML 的装配通常采用两种实现方式,即设值注入(Setter Injection)和构造注入...
  • 大家好,我是邵奈一,一个不务正业的程序猿、正儿八经的斜杠青年。 1、世人称我为:被代码耽误的诗人、没天赋的书法家、五音不全...教程目录0x00 教程内容0x01 Spring配置文件的编写1. 引入依赖2. 新建Spring的配置文.
  • Spring Bean注入不成功

    2021-04-09 17:49:33
    bean注入不成功 Caused by: org.springframework.beans.factory.NoSuchBeanDefinitionException: No qualifying bean of type '' available: expected at least 1 bean which qualifies as autowire candidate. ...
  • IOC操作bean管理 目前创建项目后文件目录: 导入的jar包五个: 这次下载的是5.2.6版本,用到了四个spring的jar包,是ioc需要的至少四个,直接jar包复制后新建lib文件夹,再粘贴到目录下,再手动添加jar包: ...
  • 二、pom.xml <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http:.
  • Spring之通过XML装配Bean

    2021-05-12 16:02:00
    IOC思想基于IOC容器完成,IOC容器底层就是对象工厂。 Spring提供IOC容器实现两种方式(两个接口): BeanFactory:IOC容器基本实现,是spring内部使用的接口,不提供给开发人员使用 加载配置文件时,不会主动创建...
  • (1)no:默认的方式是不进行自动装配的,通过手工设置ref属性来进行装配bean。 (2)byName:通过bean的名称进行自动装配,如果一个bean的 property 与另一bean 的name 相同,就进行自动装配。 (3)byType:通过...
  • Spring XML配置bean,空指针异常,自动装配使用不当产生的NullPointerException 2个类如下 异步服务 AsyncService AsyncServiceImp 天气服务 WeatherService WeatherServiceImp 代码简写如下 public class ...
  • 来源:juejin.cn/post/6844903813753602056通过注解注入Bean背景我们谈到Spring的时候一定会提到IOC容器、DI依赖注入,Spring通过将一个个类标...
  • 当我们想要将组件注入Spring的IOC容器中,除了@Controller、@Service、@Repository、@Component,还有一些常用的方法,下面我就这些方法简单的介绍下。 ps:下面所有的输出都是基于以下代码: public void testBean...
  • Spring基于XML装配bean

    2021-04-17 14:01:39
    详细介绍了通过xml装配bean的过程,介绍了xml中各种标签的使用方式。
  • 注入bean的名字不对 下面是一些简单的例子 短信接口 public interface SmsService {} 短信实现类接口 @Service("smsServiceImpl") public class SmsServiceImpl implements SmsService {} 短信控制器 @...
  • 创建xml文件并将bean配置到文件中→ 创建applicationcontext对象来从容器中得到bean→ 测试调用bean的方法 1. pom文件导入spring-context的坐标 创建接口 创建接口实现类 创建xml文件并配置bean 创建...
  • spring约束需要在spring官网复制 为了省去麻烦 这里直接给出网址Core Technologies 方框中的就是约束 把它复制下来放到xml文件中 这里只是简单的约束 下面是全部约束 <beans xmlns=...
  • 一、bean生命周期-后处理bean(Bean后处理器) 1、编写一个类实现接口BeanPostProcessor 实现接口中的两个方法 public class LifeCycle implements BeanPostProcessor { public Object ...
  • 2-Spring-基于xml配置bean

    2021-10-10 19:09:23
    Spring-基于xml配置bean 文章目录Spring-基于xml配置bean一. Bean实例化的4种方式1.1 无参数构造方法(开发最常用)1.2 静态工厂方法1.3 实例工厂方法1.4 FactoryBean方式(Spring底层使用较多)1.5 FactoryBean 与 ...
  • 创建user实体类4.resources目录下创建bean.xml文件5.测试注入是否成功 1.创建maven工程 2.pom文件引入依赖 <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" ...
  • spring-210724-04–IOC容器–Bean管理XML方式-注入空值和特殊符号 beantest21072401.xml(笔记在注释中哦) TestBean21072401.java beantest21072401.xml(笔记在注释中哦) <?xml version="1.0" encoding=...
  • public class CarFactory { //非...对于非静态方法createCar的注入方式: 非静态方法:必须实例化工厂类(factory-bean)后才能调用工厂方法 <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi=...
  • 一、Spring基于XML装配Bean Bean 的装配可以理解为依赖关系注入Bean 的装配方式也就是 Bean 的依赖注入方式。Spring容器支持多种形式的 Bean 的装配方式,如基于 XMLBean 装配、基于 Annotation 的 Bean ...
  • 在装配bean的时候,还有一种可选方案。官方可能认为这种方式不好,因为非 java 代码配置,但是每个人的看法和喜好不同,也...最为简单的Spring XML配置如下所示: <?xml version="1.0" encoding="UTF-8"?> <.
  • @Componentpublic class Cv {public String fff() {return "fff";}}```---```java@Componentpublic class VC {public String dd(){return ...}}```---```xmlxmlns:xsi="http://www.w3.org/2001/XMLSchema-instan...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 205,173
精华内容 82,069
关键字:

spring基于xml注入bean

spring 订阅