java:Spring框架2(bean的作用域,静态工厂和实例工厂,自动装配,动态代理)
1.bean的作用域,静态工厂和实例工厂:
bean.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"
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">
<!--
bean的作用域可以使用scope属性指定,默认为单例(singleton),scope="singleton|prototype"
singleton:单例,针对所有的请求只创建一个对象
prototype:原型,针对每一次请求都会创建一个对象
bean的生命周期
1.如果作用域为singleton,当容器初始化时创建对象.
2.如果作用域为prototype时,初始化容器时不会创建对象,当调用getBean方法时才真正创建。
-->
<bean id="user" class="cn.zzsxt.entity.Userinfo" scope="singleton"></bean>
<!--
使用无参静态工程方法创建对象
factory-method="静态工程方法的名称"
-->
<bean name="user2" class="cn.zzsxt.entity.UserFactory" factory-method="getInstatnce"></bean>
<bean id="user3" class="cn.zzsxt.entity.UserFactory" factory-method="getInstatnce">
<constructor-arg index="0" value="1"></constructor-arg>
<constructor-arg index="1" value="zhangsan"></constructor-arg>
<constructor-arg index="2" value="1234"></constructor-arg>
</bean> <!-- 实例工厂方法 -->
<!-- 1.创建工厂实例 init="初始化方法" destory="销毁的方法"-->
<bean id="userFactory" class="cn.zzsxt.entity.UserFactory2" init-method="init" destroy-method="destory"></bean>
<!-- 2.通过工厂实例的工厂方法创建对象 -->
<bean id="user4" factory-bean="userFactory" factory-method="getInstatnce"></bean>
<bean id="user5" factory-bean="userFactory" factory-method="getInstatnce">
<constructor-arg index="0" value="1"></constructor-arg>
<constructor-arg index="1" value="zhangsan"></constructor-arg>
<constructor-arg index="2" value="1234"></constructor-arg>
</bean>
</beans>
beans2.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"
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" default-autowire="byName">
<bean id="userinfoDao" class="cn.zzsxt.dao.impl.UserinfoJdbcDaoImpl"></bean>
<!--
自动装配:autowire="byType|byName|constructor"
byType:通过属性的类型进行自动装配:会根据属性类型在spring容器查找与其相同类型的bean,然后进行注入
要求:当前spring容器待注入的类型要唯一,否则将抛出NoUniqueBeanDefinitionException异常
byName:通过属性名称进行自动装配:会根据属性名称在spring容器查找与其相同名称的bean,然后进行注入
要求:属性名称必须与spring容器中待注入的bean的id一致。
constructor:通过构造方法进行自动装配:优先使用byName自动装配模式调用构造方法进行bean对象的构建.
如果byName自动装配模式无法匹配所有的构造参数,则根据byType自动装配模式调用构造方法进行bean对象的构建.
这时如果有多个同类型bean,会在构建bean对象时抛出异常
beans标签中的属性 : default-autowire
在beans标签中可以通过配置属性default-autowire为所有bean子标签配置默认的自动装配模式,
属性可选值与含义与bean标签的autowire属性一致. 参考配置文件如下:
-->
<bean id="userinfoService" class="cn.zzsxt.service.impl.UserinfoServiceImpl" autowire="byName"></bean>
</beans>
UserFactory:
package cn.zzsxt.entity; public class UserFactory { /**
* 无参的静态工程方法
* @return
*/
public static Userinfo getInstatnce(){
return new Userinfo();
} /**
* 带参的静态工程方法
* @param userId
* @param userName
* @param userPass
* @return
*/
public static Userinfo getInstatnce(int userId,String userName,String userPass){
return new Userinfo(userId,userName,userPass);
} }
UserFactory2:
package cn.zzsxt.entity; public class UserFactory2 {
//初始化方法
public void init(){
System.out.println("init().....");
}
/**
* 无参的实例工程方法
* @return
*/
public Userinfo getInstatnce(){
return new Userinfo();
} /**
* 带参的实例工程方法
* @param userId
* @param userName
* @param userPass
* @return
*/
public Userinfo getInstatnce(int userId,String userName,String userPass){
return new Userinfo(userId,userName,userPass);
} //销毁的方法
public void destory(){
System.out.println("destory()...");
} }
UserinfoServiceImpl:
package cn.zzsxt.service.impl; import cn.zzsxt.dao.UserinfoDao;
import cn.zzsxt.entity.Userinfo;
import cn.zzsxt.service.UserinfoService; public class UserinfoServiceImpl implements UserinfoService {
private UserinfoDao userinfoDao; public UserinfoServiceImpl(){ } public void setUserinfoDao(UserinfoDao userinfoDao) {
System.out.println("通过setter进行注入");
this.userinfoDao = userinfoDao;
} public UserinfoServiceImpl(UserinfoDao userinfoDao) {
System.out.println("通过构造函数注入");
this.userinfoDao = userinfoDao;
} @Override
public void save(Userinfo user) {
System.out.println(userinfoDao);
userinfoDao.save(user);
} }
TestInstanceFactory:
package cn.zzsxt.test; import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext; import cn.zzsxt.entity.Userinfo; public class TestInstanceFactory {
public static void main(String[] args) {
ApplicationContext ac = new ClassPathXmlApplicationContext("beans.xml");
Userinfo user = (Userinfo)ac.getBean("user4");
System.out.println(user);
System.out.println("------------------");
Userinfo user2 = (Userinfo)ac.getBean("user5");
System.out.println(user2);
}
}
TestScope:
package cn.zzsxt.test; import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext; import cn.zzsxt.entity.Userinfo; public class TestScope {
public static void main(String[] args) {
ApplicationContext ac = new ClassPathXmlApplicationContext("beans.xml");
Userinfo user = (Userinfo)ac.getBean("user");
// Userinfo user2 = (Userinfo)ac.getBean("user");
// System.out.println(user==user2);
}
}
TestStaticFactory:
package cn.zzsxt.test; import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext; import cn.zzsxt.entity.Userinfo; public class TestStaticFactory {
public static void main(String[] args) {
ApplicationContext ac = new ClassPathXmlApplicationContext("beans.xml");
Userinfo user = (Userinfo)ac.getBean("user2");
System.out.println(user);
System.out.println("------------------");
Userinfo user2 = (Userinfo)ac.getBean("user3");
System.out.println(user2);
}
}
TestAutoWire:
package cn.zzsxt.test2; import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext; import cn.zzsxt.entity.Userinfo;
import cn.zzsxt.service.UserinfoService; public class TestAutoWire {
public static void main(String[] args) {
ApplicationContext ac = new ClassPathXmlApplicationContext("beans2.xml");
UserinfoService userinfoService = (UserinfoService)ac.getBean("userinfoService");
Userinfo user = new Userinfo(1,"test","test");
userinfoService.save(user);
}
}
2.动态代理:
ProductDaoImpl:
package cn.zzsxt.dao.impl; import cn.zzsxt.dao.ProductDao; public class ProductDaoImpl implements ProductDao { @Override
public void add() {
System.out.println("利用hibernate执行商品的添加...");
} }
ProductDaoProxy:
package cn.zzsxt.dao.impl; import cn.zzsxt.dao.ProductDao; public class ProductDaoProxy implements ProductDao {
private ProductDao productDao;//被代理目标 public ProductDaoProxy(ProductDao productDao) {
this.productDao = productDao;
} @Override
public void add() {
System.out.println("开启事务....");
productDao.add();
System.out.println("提交事务....");
} }
UserinfoDaoImpl:
package cn.zzsxt.dao.impl; import cn.zzsxt.dao.UserinfoDao; public class UserinfoDaoImpl implements UserinfoDao { @Override
public void save() {
System.out.println("利用hibernate执行了用户新增...");
} }
UserinfoDaoProxy:
package cn.zzsxt.dao.impl; import cn.zzsxt.dao.UserinfoDao; public class UserinfoDaoProxy implements UserinfoDao {
private UserinfoDao userinfoDao;//被代理目标 public UserinfoDaoProxy(UserinfoDao userinfoDao) {
this.userinfoDao = userinfoDao;
} @Override
public void save() {
System.out.println("开启事务....");
userinfoDao.save();
System.out.println("提交事务....");
}
}
JDKProxy:(基于接口的实现)
package cn.zzsxt.proxy; import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy; /**
*
* JDK动态代理:使用前提(基于接口的实现)
* JDK动态代理:本质上生产了一个代理类,该代理与被代理目标实现相同的接口,
* 当前用户访 问代理类中的方法时,将委派InvacationHandler中的invoke()方法进行处理,
* 在invoke()方法中添加业务处理代理和回调被代理目标中方法。
* @author Think
*
*/
public class JDKProxy implements InvocationHandler{
private Object target;//被代理目标 public JDKProxy(Object target){
this.target=target;
} /**
* 生成代理
*/
public Object createProxy(){
/**
* loader - 定义代理类的类加载器
interfaces - 代理类要实现的接口列表
h - 指派方法调用的调用处理程序
*/
return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), this);
}
/**
* proxy - 在其上调用方法的代理实例
* method - 对应于在代理实例上调用的接口方法的 Method 实例
* args - 包含传入代理实例上方法调用的参数值的对象数组
*/
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("开启事务....");
Object returnValue = method.invoke(target, args);//回调被代理目标的方法
System.out.println("提交事务....");
return returnValue;
} }
TestJDKProrxy:
package cn.zzsxt.proxy; import cn.zzsxt.dao.ProductDao;
import cn.zzsxt.dao.UserinfoDao;
import cn.zzsxt.dao.impl.ProductDaoImpl;
import cn.zzsxt.dao.impl.UserinfoDaoImpl; public class TestJDKProrxy {
public static void main(String[] args) {
JDKProxy proxy = new JDKProxy(new UserinfoDaoImpl());
UserinfoDao userinfoDao = (UserinfoDao)proxy.createProxy();//创建代理
userinfoDao.save();
System.out.println("-------------------");
// JDKProxy proxy2 = new JDKProxy(new ProductDaoImpl());
// ProductDao productDao = (ProductDao)proxy2.createProxy();//创建代理
// productDao.add(); }
}
GglibProxy:(基于父类实现:cglib动态代理)
package cn.zzsxt.proxy2; import java.lang.reflect.Method; import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy; /**
* cglib:基于父类实现:cglib动态代理.
* 本质上动态生成了一个被代理目标的子类(要求被代理类不是final修饰的类),
* 通过多态实现功能的加强,当访问代理中的方法时,
* 委派给MethodInteceptor中的处理程序(intercept方法)进行出来,
* 在处理程序中添加了业务逻辑和回掉了被代理目标中的方法。
*
* @author Think
* 实现步骤:
* 1.添加cglib依赖的jar文件
* cglib-2.2.2.jar,asm-3.3.1.jar,asm-util-3.3.1.jar,ant-1.6.2.jar
* 2.创建Enhancer对象
* Enhancer enhancer = new Enhancer();
* 3.设置基类(父类)
* enhancer.setSuperclass(target.getClass());
* 4.设置回调接口
* enhancer.setCallback(this);//MethodInterceptor实现类
* 5.创建动态代理
enhancer.create();
*
*
*/
public class GglibProxy implements MethodInterceptor{
private Object target; public GglibProxy(Object target){
this.target=target;
} public Object createProxy(){
//创建Enhancer对象
Enhancer enhancer = new Enhancer();
//设置基类
enhancer.setSuperclass(target.getClass());
//设置回调接口
enhancer.setCallback(this);
//创建代理
return enhancer.create(); } @Override
public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
System.out.println("开启事务.....");
Object value = method.invoke(target, args);//回掉被代理目标中的方法
System.out.println("提交事务....");
return value;
} public static void main(String[] args) {
GglibProxy cglibProxy = new GglibProxy(new OrderDao());
OrderDao orderDao = (OrderDao)cglibProxy.createProxy();
orderDao.add();
} }
OrderDao:
package cn.zzsxt.proxy2; public class OrderDao {
public void add(){
//System.out.println("开启事务...");
System.out.println("添加了订单....");
//System.out.println("提交事务...");
}
}
OrderDaoProxy:
package cn.zzsxt.proxy2; public class OrderDaoProxy extends OrderDao{ @Override
public void add() {
System.out.println("开启事务..");
super.add();
System.out.println("提交事务...");
} public static void main(String[] args) {
// OrderDao orderDao = new OrderDao();
OrderDao orderDao = new OrderDaoProxy();
orderDao.add();
}
}
java:Spring框架2(bean的作用域,静态工厂和实例工厂,自动装配,动态代理)的更多相关文章
- 《Java Spring框架》SpringXML配置详解
Spring框架作为Bean的管理容器,其最经典最基础的Bean配置方式就是纯XML配置,这样做使得结构清晰明了,适合大型项目使用.Spring的XML配置虽然很繁琐,而且存在简洁的注解方式,但读懂X ...
- Spring基础11——Bean的作用域
1.Bean的作用域种类 Spring中的bean的作用域分为四种:singleton.prototype.session.request,后两种很少使用,下面我们主要来学习前两种 2.singlet ...
- 【Spring】Spring中的Bean - 2、Baen的实例化 (构造器、静态工厂、实例工厂)
Bean的实例化 文章目录 Bean的实例化 构造器实例化 静态工厂方式实例化 实例工厂方式实例化 简单记录-Java EE企业级应用开发教程(Spring+Spring MVC+MyBatis)-S ...
- 极简SpringBoot指南-Chapter01-如何用Spring框架声明Bean
仓库地址 w4ngzhen/springboot-simple-guide: This is a project that guides SpringBoot users to get started ...
- (转)配置Spring管理的bean的作用域
http://blog.csdn.net/yerenyuan_pku/article/details/52833477 Spring管理的bean的作用域有: singleton 在每个Spring ...
- Spring第一课:基于XML装配bean(四),三种实例化方式:默认构造、静态工厂、实例工厂
Spring中基于XML中的装配bean有三种方式: 1.默认构造 2.静态工厂 3.实例工厂 1.默认构造 在我们在Spring的xml文件中直接通过: <bean id=" ...
- 吴裕雄--天生自然JAVA SPRING框架开发学习笔记:Spring中Bean的作用域
作用域的种类 Spring 容器在初始化一个 Bean 的实例时,同时会指定该实例的作用域.Spring3 为 Bean 定义了五种作用域,具体如下. 1)singleton 单例模式,使用 sing ...
- [原创]java WEB学习笔记102:Spring学习---Spring Bean配置:bean配置方式(工厂方法(静态工厂方法 & 实例工厂方法)、FactoryBean) 全类名
本博客的目的:①总结自己的学习过程,相当于学习笔记 ②将自己的经验分享给大家,相互学习,互相交流,不可商用 内容难免出现问题,欢迎指正,交流,探讨,可以留言,也可以通过以下方式联系. 本人互联网技术爱 ...
- 理解Spring框架中Bean的5个作用域
当通过spring容器创建一个Bean实例时,不仅可以完成Bean实例的实例化,还可以为Bean指定特定的作用域.Spring支持如下5种作用域: singleton:单例模式,在整个Spring I ...
随机推荐
- Android九宫格解锁有多少种姿势
参考知乎:知乎.
- mysql自增字段AUTO_INCREMENT重排或归零
由于删除了某些记录行,导致自增字段不连续了,重排或归零的方法: 方法1:truncate table 你的表名//这样不但重新定位自增的字段,而且会将表里的数据全部删除,慎用! 方法2:delete ...
- maven项目引入外部jar包
方式1:dependency 本地jar包 <dependency> <groupId>com.hope.cloud</groupId> <!--自定义--& ...
- 采用线性回归方法降低双目测距到平面的误差(sklearn)
继上篇,为了改善标定板的深度信息: remove_idx1 = np.where(Z <= 0) remove_idx2 = np.where(Z > 500)#将Z轴坐标限定在0-500 ...
- No module named 'winrandom'。
问题:在windows的python3使用PyCrypto出现ImportError: No module named 'winrandom'错误处理:修改python3安装目录下的 lib/Cry ...
- qt5--定时器
定时器方式一:----定时器事件 需要 #include <QTimerEvent> #include "win.h" #include <QDebug& ...
- LINUX学习之一基础篇
1.计算机硬件五大单元:运算器.控制器.存储器.I/O设备 2.CPU种类:精简指令集(RISC)和复杂指令集(CISC) 3.1Byte=8bit,扇区大小为512bytes 4.芯片组通常分为两个 ...
- css设置元素垂直居中的几个方法
最近有人问我怎么设置元素垂直居中?我....(这么基础的东西都不会?我有点说不出话来), 不过还是耐心的教了他几个方法,好吧教完他们,顺便把这些方法整理一下 第一种:通过设置成为表格元素的方式来实现 ...
- CAP拾遗
概念 在一个分布式系统(指互相连接并共享数据的节点的集合)中,当涉及读写操作时,只能保证一致性.可用性.分区容错性三者中的两个,另外一个必须被牺牲 Consistency 对某个指定的客户端来说,读操 ...
- JS大文件上传断点续传解决方案
1 背景 用户本地有一份txt或者csv文件,无论是从业务数据库导出.还是其他途径获取,当需要使用蚂蚁的大数据分析工具进行数据加工.挖掘和共创应用的时候,首先要将本地文件上传至ODPS,普通的小文件通 ...