第二讲 bean是个什么东西！

最新推荐文章于 2022-06-12 13:41:38 发布

zp_jit

最新推荐文章于 2022-06-12 13:41:38 发布

阅读量469

点赞数

分类专栏： web开发

本文链接：https://blog.csdn.net/zpjlkjxy/article/details/79939519

版权

web开发专栏收录该内容

12 篇文章 0 订阅

订阅专栏

简介：

今天是学习ssm的第二天，主要是学习了下spring 中的bean。其实第一讲已经用到了，这一讲来主要讨论一下。

首先回顾一下概念和理论：

1.上一讲里面在xml文件里面配置过bean，其实spring是负责管理和生产bean的，所以 bean具体怎么实现使用是需要我们自己来配置的。

2.实际开发中最常用的配置方法是使用xml文件配置。xml文件中用<beans>标签来说明，而每一个它的子元素<bean>代表声明了一个bean，并描述了如何实现。（具体看代码）

3.bean里面有很多标签，常用的id（相当于变量名吧），class（你想变成bean的目标类的具体实现类，全限定名）。scope（指定作用域），constructor—arg（构造参数实例化），property（用于依赖注入），ref（引用），value（常量值）。list，map，set，entry就不说了。后面代码都会用到。

4.一般bean的配置文件只需要id和class属性即可。

5.bean的实例化方式有三种，构造器实例化，静态工厂实例化以及实例工厂实例化。（后面有实现代码具体讨论）

6.bean的作用域常见的是singleton（默认）和prototype。对于getbean方法，前者每次返回的都是同一个bean，而后者每次都新建一个bean（后面有代码示范）。而bean的生命周期也会因此改变（在bean的生成和销毁有时需要执行一些操作，所以生命周期有必要了解）。前者能控制bean的创建与销毁，而后者只负责创建，然后就丢给调用者~

7.bean的装配方式：xml装配（构造注入和，设值注入），基于注解的装配，自动装配。

代码实现：

bean实例化的方式：

1.构造器实例化：

先上bean1类：

package com.instance.constructor;

public class Bean1 {
	
}

再来个测试类：

package com.instance.constructor;

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

public class InstanceTest1 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//定义配置文件路径
		String xmlPath="com/instance/constructor/beans1.xml";
		//ApplicationContext 对bean实例化。
		/*这里用了另一种配置方式，用绝对路径作为参数，第一讲我是在src目录下建的xml文件，所以不需要，这里在包里建的，所以鼠标右击xml copy 一下qualified name*/
		ApplicationContext applicationContext=new ClassPathXmlApplicationContext(xmlPath);
		//得到bean。即xml文件里配置的那玩意。
		Bean1 bean=(Bean1) applicationContext.getBean("bean1");
		System.out.println(bean);//得到地址说明成功了。
		//Spring加载时，通过id为bean1的实现类Bean1的无参构造方法实例化bean，此即构造器实例化
	}

}

最后上配置文件：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" 
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://www.springframework.org/schema/beans 
		http://www.springframework.org/schema/beans/spring-beans-4.3.xsd"><!-- 注明spring版本 -->
	<bean id="bean1" class="com.instance.constructor.Bean1"/>
</beans>

2.静态工厂实例化：

先上bean2类：

package com.instance.static_factory;

public class Bean2 {

}

然后是bean工厂（内含静态构造bean的方法）：

package com.instance.static_factory;

public class MyBean2Factory {
	
	public static Bean2 createBean() {//静态方法
		return new Bean2();
	}
}

然后xml文件：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" 
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://www.springframework.org/schema/beans 
		http://www.springframework.org/schema/beans/spring-beans-4.3.xsd"><!-- 注明spring版本 -->
	<bean id="bean2" class="com.instance.static_factory.MyBean2Factory" factory-method="createBean"/>
	<!-- 这里class是bean工厂类，而我们要的不是bean工厂的实例化而是bean工厂用静态方法生产的bean2的实例化，所以后面指定下使用的方法 -->
</beans>

最后测试类：

package com.instance.static_factory;

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

public class InstanceTest2 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		ApplicationContext applicationContext=new ClassPathXmlApplicationContext("com/instance/static_factory/beans2.xml");
		System.out.println(applicationContext.getBean("bean2"));//获取到bean2的地址而不是bean工厂的
		//这就是所谓的bean工厂的实例化，通过工厂类生产出bean2实例。
	}

}

3.实例化工厂方式（我觉得这个和上面那个差不多上面那个没有实例化工厂，只是用它的静态方法创建bean，这个就是把工厂给实例化了，再去实例化bean，具体三种方式的区别我暂时没研究，以后懂了会补上）：

bean3类：

package com.instance.factory;

public class Bean3 {

}

工厂类：

package com.instance.factory;

public class MyBean3Factory {
	
	public MyBean3Factory() {
		System.out.println("bean3实例工厂化");//证明工厂实例化了
	}
	public Bean3 createBean() {
		return new Bean3();
	}
}

xml文件：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" 
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://www.springframework.org/schema/beans 
		http://www.springframework.org/schema/beans/spring-beans-4.3.xsd"><!-- 注明spring版本 -->
	<!-- 先配置工厂 -->
	<bean id="mybean3Factory" class="com.instance.factory.MyBean3Factory"/>
	<!-- 再配置bean，注意元素标签的使用-->
	<bean id="bean3" factory-bean="mybean3Factory" factory-method="createBean"></bean>
</beans>

测试类：

package com.instance.factory;

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

public class InstanceTest3 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//指定配置文件路径
		String xmlPath="com/instance/factory/beans3.xml";
		ApplicationContext applicationContext =new ClassPathXmlApplicationContext(xmlPath);
		System.out.println(applicationContext.getBean("bean3"));
		//此即实例化工厂，先配置了实例工厂，再配置bean
	}
}

生命周期的演示：

life类：

package com.life;

public class Life {
	
	public Life() {//证明实例化了
		System.out.println("Start");
	}
	public void initMethod() {//证明初始化了
		System.out.println("init start");
	}
	public void destroyMethod() {//证明销毁了
		System.out.println("des start");
	}
}

xml文件：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" 
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://www.springframework.org/schema/beans 
		http://www.springframework.org/schema/beans/spring-beans-4.3.xsd"><!-- 注明spring版本 -->
	<!-- 自定义初始化和销毁方法 -->
	<bean id="bean1" class="com.life.Life" init-method="initMethod" destroy-method="destroyMethod"/>
</beans>

测试类：

package com.life;

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

public class LifeTest {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		ClassPathXmlApplicationContext context=new ClassPathXmlApplicationContext("com/life/life.xml");
		//classpathxmlapplicationcontext提供了close方法会自动调用销毁方法
		context.close();
	}

}

作用域：

测试类：

package com.scope;

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

public class SvpeTest {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		ApplicationContext applicationContext=new ClassPathXmlApplicationContext("com/scope/beans4.xml");
		System.out.println(applicationContext.getBean("bean4"));
		System.out.println(applicationContext.getBean("bean4"));
		/*加载配置文件，输出获得的实例。singleton的话就是说你两次getbean()最后得到的bean是同一个bean4，得到的地址也是一样的。
		 * prototype的话两次输出的地址是不一样的。
		 * */
	}

}

scope类：

package com.scope;

public class Scope {

}

xml文件：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" 
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://www.springframework.org/schema/beans 
		http://www.springframework.org/schema/beans/spring-beans-4.3.xsd"><!-- 注明spring版本 -->
	<!--  <bean id="bean4" class="com.scope.Scope" scope="singleton"/>-->
	<bean id="bean4" class="com.scope.Scope" scope="prototype"/>
</beans>

bean的装配方式：

1.基于xml方式装配：

xml文件：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" 
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://www.springframework.org/schema/beans 
		http://www.springframework.org/schema/beans/spring-beans-4.3.xsd"><!-- 注明spring版本 -->
<!-- 使用构造注入方式装配user实例 -->
	<bean id="user1" class="com.assemble.User">
		<constructor-arg index="0" value="tom"/><!-- 构造注入专用标签~~~，索引代表构造方法参数表的顺序 -->
		<constructor-arg index="1" value="123456"/>
		<constructor-arg index="2"><!-- list的注入方式 -->
			<list>
				<value>"constructorvalue1"</value>
				<value>"constructorvalue2"</value>
			</list>
		</constructor-arg>
	</bean>
<!-- 使用设值注入方式装配user实例 -->
	<bean id="user2" class="com.assemble.User">	
		<property name="username" value="zp"></property><!-- 设值注入的专用标签 -->
		<property name="password" value="654321"></property>
		<property name="list">
			<list>
				<value>"setlistvalue1"</value>
				<value>"setlistvalue2"</value>
			</list>
		</property>
	</bean>
</beans>

User类：

package com.assemble;

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

public class XmlBeanAssembleTest {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		String xmlPath="com/assemble/beans5.xml";
		ApplicationContext applicationContext =new ClassPathXmlApplicationContext(xmlPath);
		//构造方式输出
		System.out.println(applicationContext.getBean("user1"));
		//设值方式输出
		System.out.println(applicationContext.getBean("user2"));
	}

}

测试类：

package com.assemble;

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

public class XmlBeanAssembleTest {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		String xmlPath="com/assemble/beans5.xml";
		ApplicationContext applicationContext =new ClassPathXmlApplicationContext(xmlPath);
		//构造方式输出
		System.out.println(applicationContext.getBean("user1"));
		//设值方式输出
		System.out.println(applicationContext.getBean("user2"));
	}

}

2.基于注解方式的装配（xml文件配置多了会很臃肿，升级维护也不方便）：

先介绍下注解的标签有哪些component，repository，service，controller（都一个功能对bean的注解，只是取了不同的名字）。autowired，resourse，qualifier（这几个是对bean中的属性和方法进行注解，第一个默认按bean的类型，第二个默认先按bean的实例名称，第三个好像是把第一个变成第二个的意思=-=，不管了）

UserDao接口：

package com.annotation;

public interface UserDao {
	
	public void save();
}

userdao的实现类：

package com.annotation;

import org.springframework.stereotype.Repository;

@Repository("userDao")
/*
 * 上面这个注解就是将UserDaoImpl这个实现类放到spring里面形成bean的意思
 * 相当于在xml文件里写<bean id="userDao" class="com.annotation.UserDaoImpl">
 * 后面的service、controller也和这一个意思
 */
public class UserDaoImpl implements UserDao {

	@Override
	public void save() {
		System.out.println("userdao...save...");//证明调用了。
	}
	
}

UserService接口：

package com.annotation;

public interface UserService {

	public void save();
}

UserService的实现类：

package com.annotation;

import javax.annotation.Resource;

import org.springframework.stereotype.Service;

@Service("userService")
public class UserServiceImpl implements UserService {

	@Resource(name="userDao")
	/*
	 * 上面这个注解，就是把xml文件里面叫userDao的那个bean（即userDao的实现类）插入到当前这个类的属性里。
	 * 相当于在xml里面写<property name="userDao" ref="userDao"/>
	 */
	private UserDao userDao;
	@Override
	public void save() {
		// TODO Auto-generated method stub
		this.userDao.save();//私有属性实例的成员函数调用
		System.out.println("userservice...save...");
	}

}

UserController类：

package com.annotation;

import javax.annotation.Resource;

import org.springframework.stereotype.Controller;

@Controller("userController")
public class UserController {

	@Resource(name="userService")
	private UserService userService;
	public void save() {
		this.userService.save();
		System.out.println("usercontroller...save...");
	}
}

xml文件：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:context="http://www.springframework.org/schema/context"
	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-4.3.xsd
		http://www.springframework.org/schema/context 
		http://www.springframework.org/schema/context/spring-context-4.3.xsd">
	<!-- 注意配置文件的变化，注解和自动装配的xml文件要发生变化 -->
	<!-- 使用context 命名空间，通知spring扫描指定包下所有的bean类，进行注解解析 -->
	
	<!--改进后只需一句话： <context:component-scan base-package="com.annotation" />-->
	



	<!-- 以下是改进前，明显还是要装配bean，只是property不用注明了 -->
	
	
	<!-- 使用context命名空间在配置文件种开启相应的注解处理器 -->
	<!-- <context:annotation-config /> -->
	<!-- 开启注解处理器 -->
	<!-- 
	<bean id="userDao" class="com.annotation.UserDaoImpl"></bean> 
	<bean id="userService" class="com.annotation.UserServiceImpl"></bean> 
	<bean id="userController" class="com.annotation.UserController"></bean> 
	-->
		
		
	
</beans>

最后测试类：

package com.annotation;

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

public class AnnotationAssembleTest {

	public static void main(String[] args) {
		String xmlPath="com/annotation/beans6.xml";
		ApplicationContext applicationContext=new ClassPathXmlApplicationContext(xmlPath);
		//获取usercontroller实例
		UserController userController=(UserController) applicationContext.getBean("userController");
		userController.save();
		//调用usercontroller中的save()方法
		
	}

}

3.自动装配：

这玩意我懒得贴代码了，就是说有的企业项目没有注解方式（很少），那什么是次优的呢，就是这玩意，你给所有类（里面有别的bean类成员作为自己成员的类）设值下setter方法，然后呢xml文件对应的bean这样写里<bean id="" class="" autowire="参数">（参数有很多类型，自己看吧）。然后起到的作用就是一般要用ref来依赖注入这些个成员属性，有了自动装配之后呢，bean的装配会自行（根据参数）去找适合的该类成员属性的xml文件中对应的bean去匹配。

zp_jit

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
第二讲 bean是个什么东西！

简介：今天是学习ssm的第二天，主要是学习了下spring 中的bean。其实第一讲已经用到了，这一讲来主要讨论一下。首先回顾一下概念和理论：1.上一讲里面在xml文件里面配置过bean，其实spring是负责管理和生产bean的，所以bean具体怎么实现使用是需要我们自己来配置的。2.实际开发中最常用的配置方法是使用xml文件配置。xml文件中用&lt;beans&gt;标签来说明，而每一个它的...
复制链接

扫一扫

专栏目录