Spring scope="prototype"

最新推荐文章于 2023-04-13 22:12:37 发布
原创 最新推荐文章于 2023-04-13 22:12:37 发布 · 136 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#prototype #Spring #Bean #Hibernate #DAO

本文探讨了SSH框架中Spring初始化不同类型的Bean（DAO、Service、Action）的方法，并详细展示了通过配置实现多态作用，确保多线程环境下Action对象的安全性。 
 

在用SSH开发项目的过程中，对于spring初始化bean这块：

显然，初始化的bean有三类：DAO、Service、Action。DAO和Service都是无状态的bean，多线程访问的时候不会出问题；而Action是有状态的。所谓有状态的bean，是bean中含有一些成员变量，按照我的理解，就是可以区分对象与对象。对于有成员变量的bean，在多个用户的访问中，可能会出现问题。具体可以见

http://blog.youkuaiyun.com/anyoneking/archive/2010/01/12/5182164.aspx

例：

DAO

package com.ultratech.omis.fa.dao;

import java.util.Date;
import java.util.List;
import org.hibernate.LockMode;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;

import com.ultratech.base.framework.BaseDAO;
import com.ultratech.omis.fa.bo.FaMaintain;

/**
 * A data access object (DAO) providing persistence and search support for
 * FaMaintain entities. Transaction control of the save(), update() and delete()
 * operations can directly support Spring container-managed transactions or they
 * can be augmented to handle user-managed Spring transactions. Each of these
 * methods provides additional information for how to configure it for the
 * desired type of transaction control.
 * 
 * @see com.ultratech.omis.fa.bo.FaMaintain
 * @author MyEclipse Persistence Tools
 */

public class FaMaintainDAO extends BaseDAO {
	private static final Logger log = LoggerFactory
			.getLogger(FaMaintainDAO.class);
	// property constants
	public static final String EQUIP_ID = "equipId";
	public static final String STATUS = "status";
	public static final String CREATE_USER_ID = "createUserId";
	public static final String CREATE_DEPT_ID = "createDeptId";
	public static final String PRIORITY = "priority";
	public static final String REPLACE = "replace";
	public static final String MAINTAIN_DEPT_ID = "maintainDeptId";
	public static final String MAINTAIN_USER_ID = "maintainUserId";
	public static final String MEMO = "memo";

	protected void initDao() {
		// do nothing
	}

	public void save(FaMaintain transientInstance) {
		log.debug("saving FaMaintain instance");
		try {
			getHibernateTemplate().save(transientInstance);
			log.debug("save successful");
		} catch (RuntimeException re) {
			log.error("save failed", re);
			throw re;
		}
	}

	public void delete(FaMaintain persistentInstance) {
		log.debug("deleting FaMaintain instance");
		try {
			getHibernateTemplate().delete(persistentInstance);
			log.debug("delete successful");
		} catch (RuntimeException re) {
			log.error("delete failed", re);
			throw re;
		}
	}

	public FaMaintain findById(java.lang.Long id) {
		log.debug("getting FaMaintain instance with id: " + id);
		try {
			FaMaintain instance = (FaMaintain) getHibernateTemplate().get(
					"com.ultratech.omis.fa.bo.FaMaintain", id);
			return instance;
		} catch (RuntimeException re) {
			log.error("get failed", re);
			throw re;
		}
	}

	public List findByExample(FaMaintain instance) {
		log.debug("finding FaMaintain instance by example");
		try {
			List results = getHibernateTemplate().findByExample(instance);
			log.debug("find by example successful, result size: "
					+ results.size());
			return results;
		} catch (RuntimeException re) {
			log.error("find by example failed", re);
			throw re;
		}
	}

	public List findByProperty(String propertyName, Object value) {
		log.debug("finding FaMaintain instance with property: " + propertyName
				+ ", value: " + value);
		try {
			String queryString = "from FaMaintain as model where model."
					+ propertyName + "= ?";
			return getHibernateTemplate().find(queryString, value);
		} catch (RuntimeException re) {
			log.error("find by property name failed", re);
			throw re;
		}
	}

	public List findByEquipId(Object equipId) {
		return findByProperty(EQUIP_ID, equipId);
	}

	public List findByStatus(Object status) {
		return findByProperty(STATUS, status);
	}

	public List findByCreateUserId(Object createUserId) {
		return findByProperty(CREATE_USER_ID, createUserId);
	}

	public List findByCreateDeptId(Object createDeptId) {
		return findByProperty(CREATE_DEPT_ID, createDeptId);
	}

	public List findByPriority(Object priority) {
		return findByProperty(PRIORITY, priority);
	}

	public List findByReplace(Object replace) {
		return findByProperty(REPLACE, replace);
	}

	public List findByMaintainDeptId(Object maintainDeptId) {
		return findByProperty(MAINTAIN_DEPT_ID, maintainDeptId);
	}

	public List findByMaintainUserId(Object maintainUserId) {
		return findByProperty(MAINTAIN_USER_ID, maintainUserId);
	}

	public List findByMemo(Object memo) {
		return findByProperty(MEMO, memo);
	}

	public List findAll() {
		log.debug("finding all FaMaintain instances");
		try {
			String queryString = "from FaMaintain";
			return getHibernateTemplate().find(queryString);
		} catch (RuntimeException re) {
			log.error("find all failed", re);
			throw re;
		}
	}

	public FaMaintain merge(FaMaintain detachedInstance) {
		log.debug("merging FaMaintain instance");
		try {
			FaMaintain result = (FaMaintain) getHibernateTemplate().merge(
					detachedInstance);
			log.debug("merge successful");
			return result;
		} catch (RuntimeException re) {
			log.error("merge failed", re);
			throw re;
		}
	}

	public void attachDirty(FaMaintain instance) {
		log.debug("attaching dirty FaMaintain instance");
		try {
			getHibernateTemplate().saveOrUpdate(instance);
			log.debug("attach successful");
		} catch (RuntimeException re) {
			log.error("attach failed", re);
			throw re;
		}
	}

	public void attachClean(FaMaintain instance) {
		log.debug("attaching clean FaMaintain instance");
		try {
			getHibernateTemplate().lock(instance, LockMode.NONE);
			log.debug("attach successful");
		} catch (RuntimeException re) {
			log.error("attach failed", re);
			throw re;
		}
	}

	public static FaMaintainDAO getFromApplicationContext(ApplicationContext ctx) {
		return (FaMaintainDAO) ctx.getBean("FaMaintainDAO");
	}
}

 

 

Service

 

package com.ultratech.omis.fa.service;

import java.util.List;

import org.hibernate.criterion.DetachedCriteria;
import org.hibernate.criterion.Order;
import org.hibernate.criterion.Restrictions;
import com.ultratech.base.framework.BaseService;
import com.ultratech.base.framework.DetachedCriteriaBuilder;
import com.ultratech.base.framework.PageMeta;
import com.ultratech.base.framework.ServiceException;
import com.ultratech.omis.fa.bo.FaMaintain;
import com.ultratech.omis.fa.bo.FaMaterialIn;
import com.ultratech.omis.fa.dao.FaMaintainDAO;

public class MaintainService extends BaseService{
	public FaMaintainDAO maintainDAO;
	
	public void saveMaintain(FaMaintain instance)throws ServiceException{
		maintainDAO.attachDirty(instance);
	}
	
	public void deleteMMaintain(FaMaintain instance) throws ServiceException {
		maintainDAO.delete(instance);
	}
	
	public void deleteMaintainById(Long maintainIds[]) throws ServiceException{
		FaMaintain instance = new FaMaintain();
		DetachedCriteria criteria = DetachedCriteriaBuilder.build(instance);
		criteria.add(Restrictions.in("maintainId", maintainIds));
		maintainDAO.getHibernateTemplate().deleteAll(maintainDAO.findByCriteria(criteria));
	}
	
	public FaMaintain findMaintainById(Long maintainId)throws ServiceException{
		return maintainDAO.findById(maintainId);
	}
	
	public List<FaMaintain> findMaintain(FaMaintain instance, PageMeta page) throws ServiceException{
		DetachedCriteria criteria = DetachedCriteriaBuilder.build(instance);
		return this.findByPage(maintainDAO, criteria, page);
	}
	
	public List<FaMaintain> findMaintain(DetachedCriteria criteria, PageMeta page) throws ServiceException {
		criteria.addOrder(Order.asc("maintainId"));
		return this.findByPage(maintainDAO, criteria, page);
	}
	
	public int getCount(DetachedCriteria criteria) throws ServiceException{
		return maintainDAO.findTotalByCriteria(criteria);
	}
	
	public FaMaintainDAO getMaintainDAO(){
		return maintainDAO;
	}
	
	public void setMaintainDAO(FaMaintainDAO maintainDAO){
		this.maintainDAO = maintainDAO;
	}
}

 

 

Action

 

package com.ultratech.omis.fa.web;

import java.util.Date;
import java.util.List;

import javax.servlet.http.HttpSession;

import org.apache.commons.beanutils.ConvertUtils;
import org.apache.struts2.ServletActionContext;

import com.ultratech.base.framework.BaseAction;
import com.ultratech.base.framework.DetachedCriteriaBuilder;
import com.ultratech.base.framework.ServiceException;
import com.ultratech.base.util.BeanTools;
import com.ultratech.base.util.Constants;
import com.ultratech.base.util.StringTools;
import com.ultratech.omis.fa.bo.FaEquipment;
import com.ultratech.omis.fa.bo.FaMaintain;
import com.ultratech.omis.fa.bo.FaMaintainLog;
import com.ultratech.omis.fa.service.EquipmentService;
import com.ultratech.omis.fa.service.MaintainLogService;
import com.ultratech.omis.fa.service.MaintainService;
import com.ultratech.omis.fnd.bo.FndUser;
import com.ultratech.omis.fnd.web.UserUtil;
//基本表中的维修人必填！！
public class MaintainEditAction extends BaseAction{
	private String maintainId;
	private String equipId;
	private String status;//
	private String createUserId;
	private String createDeptId;
	private String createDate;
	private String priority;///
	private String replace;///
	private String maintainDeptId;//从基本表信息取
	private String maintainUserId;
	private String fixDate;//不填
	private String fixMethod;//不填
	private String memo;
	private FaEquipment faEquipment;
	private List<FaMaintainLog> maintainLogList;
	
	private MaintainService maintainService;
	private EquipmentService equipmentService;
	private MaintainLogService maintainLogService;
	
    
    public MaintainEditAction(MaintainService maintainService, EquipmentService equipmentService, MaintainLogService maintainLogService){
    	this.maintainService = maintainService;
    	this.equipmentService = equipmentService;
    	this.maintainLogService = maintainLogService;
    }
	
	public void prepare() throws Exception {
		clearErrorsAndMessages();
	}

	public String save(){
		FndUser user = this.getUser();
		//保存维修记录及日志，更改基本表
		FaMaintain instance = new FaMaintain();
		FaMaintainLog log = new FaMaintainLog();
		BeanTools.copyProperties(instance, this);//equipId
		try {
			FaEquipment old = equipmentService.FindEquipmentById(StringTools.parseLong(equipId));
			old.setHealthStatus("01");//损坏
			instance.setStatus("00");//报修
			instance.setCreateDate(new Date());
			instance.setCreateDeptId(user.getDeptId());
			instance.setCreateUserId(user.getUserId());
			instance.setMaintainDeptId(old.getMaintainDeptId());
			instance.setMaintainUserId(old.getMaintainUserId());
			instance.setFaEquipment(old);
			maintainService.saveMaintain(instance);	//维修表
			log.setMaintainId(instance.getMaintainId());
			log.setCreateDeptId(user.getDeptId());
			log.setCreateUserId(user.getUserId());
			log.setCreateDate(new Date());
			log.setMemo(memo);
			maintainLogService.saveMaintainLog(log);//报修日志
			equipmentService.saveEquipment(old);	//基本表
			return SUCCESS;
		} catch (ServiceException ex) {
			ex.printStackTrace();
			this.addActionError(ex.getMessage());
			return INPUT;
		}
	}
	
	public boolean isModified() {
		try {
			FaMaintain old = maintainService.findMaintainById(StringTools.parseLong(maintainId));
			if(old != null) {
				if(
						((old.getFixMethod() != null) && old.getFixMethod().equals(fixMethod)) 
						&& ((old.getMaintainDeptId() == null && (maintainDeptId == null || maintainDeptId.equals(""))) || (old.getMaintainDeptId() != null && old.getMaintainDeptId().toString().equals(maintainDeptId)))
						&& ((old.getMaintainUserId() == null && (maintainUserId == null || maintainUserId.equals(""))) || (old.getMaintainUserId() != null && old.getMaintainUserId().toString().equals(maintainUserId))) 
						&& ((old.getStatus() == null && (status == null || status.equals(""))) || (old.getStatus() != null && old.getStatus().toString().equals(status))) 
						&& old.getMemo().equals(memo)
					) {
					return false;
				} else
					return true;
			}
			else
					return false;
		}catch(ServiceException ex) {
			ex.printStackTrace();
			return false;
		}
	}
	
	public String saveAssigned() {
		try {
			FaMaintain old = maintainService.findMaintainById(StringTools.parseLong(maintainId));
			//判断改没有，改了就产生新日志
			if(this.isModified()) {
				FaMaintainLog log = new FaMaintainLog();
				old.setMaintainDeptId(StringTools.parseLong(maintainDeptId));
				old.setMaintainUserId(StringTools.parseLong(maintainUserId));
				//old.setStatus("11");//维修中
				FaEquipment t = equipmentService.FindEquipmentById(old.getEquipId());
				t.setMaintainDeptId(StringTools.parseLong(maintainDeptId));
				t.setMaintainUserId(StringTools.parseLong(maintainUserId));
				old.setStatus(status);
				if(status.equals("90")) {  //已修复
					log.setMemo(memo+"。设备已修好！");
					old.setFixDate(new Date());
					t.setHealthStatus("00");//正常
				}
				else {
					log.setMemo(memo);
				}
				equipmentService.saveEquipment(t);
				old.setFixMethod(fixMethod);
				old.setMemo(memo);
				maintainService.saveMaintain(old);
				log.setCreateDate(new Date());
				log.setMaintainId(StringTools.parseLong(maintainId));
				log.setCreateDeptId(StringTools.parseLong(maintainDeptId));
				log.setCreateUserId(StringTools.parseLong(maintainUserId));
				maintainLogService.saveMaintainLog(log);
			}
			return SUCCESS;
		} catch (ServiceException ex) {
			ex.printStackTrace();
			this.addActionError(ex.getMessage());
			return INPUT;
		}
	}
	
	public String info(){
		try {
			FaMaintain instance;
			instance = maintainService.findMaintainById(StringTools.parseLong(maintainId));
			BeanTools.copyProperties(this, instance);
			this.faEquipment = equipmentService.FindEquipmentById(instance.getEquipId());
			createDate = StringTools.formatDate(instance.getCreateDate());
			fixDate = StringTools.formatDate(instance.getFixDate());
			//找出相关日志
			FaMaintainLog log = new FaMaintainLog();
			log.setMaintainId(StringTools.parseLong(maintainId));
			maintainLogList = maintainLogService.findMaintainLog(log, null);
			return SUCCESS;
		} catch (ServiceException e) {
			e.printStackTrace();
			return ERROR;
		}
	}
	
	public String delete(){
		String[] values = ServletActionContext.getRequest().getParameterValues("maintainId");
		Long[] MaintainIds = (Long[]) ConvertUtils.convert(values, Long.class);
		try {
			maintainService.deleteMaintainById(MaintainIds);
			return SUCCESS;
		} catch (ServiceException e) {
			e.printStackTrace();
			return ERROR;
		}
	}
	
	public String assign() {
		String[] values = ServletActionContext.getRequest().getParameterValues("maintainId");
		Long[] maintainIds = (Long[]) ConvertUtils.convert(values, Long.class);
		try {
			for(int i = 0; i < maintainIds.length; i++) {
				FaMaintainLog log = new FaMaintainLog();
				FaMaintain faMaintain = maintainService.findMaintainById(maintainIds[i]);
				log.setMaintainId(faMaintain.getMaintainId());
				log.setCreateDate(new Date());
				log.setCreateDeptId(faMaintain.getCreateDeptId());
				log.setCreateUserId(faMaintain.getCreateUserId());
				log.setMemo("下达任务");
				maintainLogService.saveMaintainLog(log);
				faMaintain.setStatus("11");
				maintainService.saveMaintain(faMaintain);
			}
			return SUCCESS;
		} catch(ServiceException e) {
			e.printStackTrace();
			return ERROR;
		}
		
	}
	
	
	public FndUser getUser() {
		HttpSession session = ServletActionContext.getRequest().getSession();
		return (FndUser)session.getAttribute(Constants.SESSION_USER);
	}
	
	public String execute() {
		try {
			this.faEquipment = equipmentService.FindEquipmentById(StringTools.parseLong(equipId));
			return SUCCESS;
		} catch (ServiceException e) {
			e.printStackTrace();
			return ERROR;
		}
	}
	
	
	public String getMaintainId() {
		return maintainId;
	}

	public void setMaintainId(String maintainId) {
		this.maintainId = maintainId;
	}

	public String getEquipId() {
		return equipId;
	}

	public void setEquipId(String equipId) {
		this.equipId = equipId;
	}

	public String getStatus() {
		return status;
	}

	public void setStatus(String status) {
		this.status = status;
	}

	public String getCreateUserId() {
		return createUserId;
	}

	public void setCreateUserId(String createUserId) {
		this.createUserId = createUserId;
	}

	public String getCreateDeptId() {
		return createDeptId;
	}

	public void setCreateDeptId(String createDeptId) {
		this.createDeptId = createDeptId;
	}

	public  String getCreateDate() {
		return createDate;
	}

	public void setCreateDate(String createDate) {
		this.createDate = createDate;
	}

	public String getPriority() {
		return priority;
	}

	public void setPriority(String priority) {
		this.priority = priority;
	}

	public String getReplace() {
		return replace;
	}

	public void setReplace(String replace) {
		this.replace = replace;
	}

	public String getMaintainDeptId() {
		return maintainDeptId;
	}

	public void setMaintainDeptId(String maintainDeptId) {
		this.maintainDeptId = maintainDeptId;
	}

	public String getMaintainUserId() {
		return maintainUserId;
	}

	public void setMaintainUserId(String maintainUserId) {
		this.maintainUserId = maintainUserId;
	}

	public String getFixDate() {
		return fixDate;
	}

	public void setFixDate(String fixDate) {
		this.fixDate = fixDate;
	}

	public String getFixMethod() {
		return fixMethod;
	}

	public void setFixMethod(String fixMethod) {
		this.fixMethod = fixMethod;
	}

	public String getMemo() {
		return memo;
	}

	public void setMemo(String memo) {
		this.memo = memo;
	}

	public FaEquipment getFaEquipment() {
		return faEquipment;
	}

	public void setFaEquipment(FaEquipment faEquipment) {
		this.faEquipment = faEquipment;
	}

	public List<FaMaintainLog> getMaintainLogList() {
		return maintainLogList;
	}

	public void setMaintainLogList(List<FaMaintainLog> maintainLogList) {
		this.maintainLogList = maintainLogList;
	}
	

}

 

 在spring的配置文件中，初始化这些bean：

<bean id="sessionFactory"
  class="org.springframework.orm.hibernate3.LocalSessionFactoryBean"><!-- Spring与Hibernate集成的桥梁 -->
  <property name="configLocation" value="classpath:hibernate.cfg.xml">
  </property>
 </bean>
<bean id="FaMaterialDAO" class="com.ultratech.omis.fa.dao.FaMaterialDAO">
		<property name="sessionFactory">
			<ref bean="sessionFactory" />
		</property>
</bean>
 <bean id="MaintainService" class="com.ultratech.omis.fa.service.MaintainService">
  <property name="maintainDAO" ref="FaMaintainDAO" />
 </bean>
<bean id="MaintainEditAction" class="com.ultratech.omis.fa.web.MaintainEditAction" scope="prototype">
  <constructor-arg ref="MaintainService" />
  <constructor-arg ref="EquipmentService"/>
  <constructor-arg ref="MaintainLogService"/>
 </bean>

 

      scope="prototype"（多态）是在每次用户发起请求时重新生成action对象，对于多线程访问不会出现问题，如果没有配置scope=prototype则添加的时候不会新建一个action，他任然会保留上次访问的过记录的信息。

      默认是scope="singleton"（单态），这些bean被spring初始化后，始终只有一份，很适用于无状态的bean，DAO、Service都采用的这种。当然，scope的值还有session,request等等。

 

 

yangzhongmin21
关注
Spring IoC容器与Bean管理16：Bean对象的作用域及生命周期一：＜bean＞的scope属性；（主要是【scope=singleton】和【scope=prototype】的分析和区别）
小枯林的博客
08-12 829
说明： （1）scope：范围、规模、广度、眼界的意思； （2）本篇博客的内容比较重要，篇幅也比较长，文字叙述较多；但是，只要理解了其中的内容，发现其实本篇博客的内容还是比较少的； （3）本篇博客内容：是【Bean对象的作用域和生命周期】中的【<bean>的scope属性简介】； 目录 一：<bean>的scope属性介绍 beanscope简介： scope用法： scope属性的可选值： 二：<bean>的scope=singleton...
Spring 源码解读：实现@Scope与自定义作用域
qq_40254606的博客
09-17 1432
`@Scope` 注解是 Spring 框架中用于控制 Bean 生命周期的机制。本文将通过手动实现 Bean 的作用域管理机制，展示如何支持自定义作用域，并与 Spring 的 `@Scope` 注解进行对比，帮助读者深入理解不同作用域的管理方式及其应用场景。
Spring的scope="prototype"属性
03-13 67
Spring的scope="prototype"属性 可以利用容器的scope="prototype"来保证每一个请求有一个单独的Action来处理， 避免struts中Action的线程安全问题。这句话怎么理解呢如果用单例方式会有什么样的结果呢？ spring 默认scope 是单例模式这样只会创建一个Action对象每次访问都是同一个Action对象，数据不安全struts2 是...
spring配置文件中：scope=“prototype“
weixin_42176639的博客
07-24 2660
在spring配置文件中，bean的属性：scope="prototype"配置说明 applicationContext.xml: <bean id="log_a" class="com.demo.action.LogAction" scope="prototype"> <property name="service" ref="log_s"></propert...
scope=“prototype“是什么意思？
ProHc的博客
06-28 4363
scope="prototype"可以保证 有请求的时候只会创建一个行为对象
Spring解决scope为prototype注入失效
kandroid的博客
04-13 461
的多例对象会注入失效，每次调用多例对象不会创建新的，因为单例对象只创建一次，所以每次获取的多例对象都是同一个；但是直接Spring容器中获取对象，每次获取的对象是不同的。都是不同的，所以可以让Spring容器来完成。中注入Bean工厂，从而从工厂中获取。是多例对象，就会出现注入失效的问题。每次从Spring容器中获取多例的。
spring的scope为prototype的bean的正确使用方法
Jaemon
12-30 4496
spring的scope为prototype的bean的正确使用方法
浅谈spring中scope作用域
08-28
<bean id="role" class="spring.chapter2.maryGame.Role" scope="prototype"/> ``` 或者 ```xml <bean id="role" class="spring.chapter2.maryGame.Role" singleton="false"/> ``` request 作用域 -----------------...
<bean id="bookService" class="com.sjj.service.impl.BookServiceimpl" scope="prototype">什么意思
最新发布
03-10
- **scope**: 设置为 `"prototype"` 指定每当调用 getBean 方法获取此类类型的 Bean 时都将返回一个全新的对象实例而不是共享相同的单一实例。 当使用上述配置后，可以通过以下方式访问并操作 `bookService` 对象：...
Spring中的singleton和prototype的实现
08-18
Spring中的singleton和prototype的实现 Spring框架中，bean的作用域是指在容器中bean的实例化和生命周期管理。其中，singleton和prototype是两个最基本的bean作用域。本文将详细介绍Spring中的singleton和...
struts2为每个线程提供一个action实例
wdreams的专栏
08-03 305
1.struts2为每个线程提供一个action实例,多线程访问时不会出现问题。当使用spring管理struts2的action实例对象时,scope必须配置为prototype或者session,若配置为singleton则多线程访问时会出现问题,例如actionMessage,fieldError等信息会累加,多用户访问时有的用户访问到的是另一个用户的数据。 2.scope=“pro...
Spring相关
okkeqin的专栏
01-23 1364
Spring的scope="prototype"属性 可以利用容器的scope="prototype"来保证每一个请求有一个单独的Action来处理，避免struts中Action的线程安全问题。这句话怎么理解呢如果用单例方式会有什么样的结果呢 spring 默认scope 是单例模式 这样只会创建一个Action对象 每次访问都是同一个Action对象，数据不安全 struts2 是要求 每
Spring注解中@Scope 的使用解说
cuichunchi的博客
01-26 1万+
案例代码 @Controller @RequestMapping("/index") @Scope("prototype") public class TestControler { final ThreadLocal local = new ThreadLocal @Autowired RestBean bean; @RequestMapping("/setPar
scope=prototype
天生我才必有用！
09-05 2012
xml配置时应在beans.xml的加上 scope=“prototype” annotation配置时应在action上注解，@scope("prototype") 这样每次请求才会创建一个新的action进行处理 能解决： 1.对象的id多次添加不会出错 2.addActionMessage()和addActionError()里面的消息对下次没有影响
scope="prototype"的使用
qq_41258326的博客
12-07 392
测试类： public class TestFactory { @Test public void demo02(){ //spring 工厂 String xmlPath="com/itheima/d_scope/applicationContext.xml"; ClassPathXmlApplicationContext applicationCon=new ClassPat...
Spring多例模式 注解@Scope("prototype")和xml配置scope="prototype"
热门推荐
u010235716的博客
06-17 1万+
这里牵扯到单利模式的线程安全的设计。 我们知道sping ioc注入的bean；一般都是无状态的【dao,service等，这种不会牵涉到值或者状态改变的情况】，也就是在多线程下可以基本保证线程安全的；但是，有些情况下可能是有状态的；有状态的bean ,是要注意线程安全的；spring是有考虑到这方面的需求的；prototype 原型类型，应运而生； 1. 首先说下spring多例模式的两种配...
java scope=prototype_spring mvc 设置@Scope("prototype")
weixin_39746229的博客
02-16 431
spring中bean的scope属性，有如下5种类型：singleton 表示在spring容器中的单例，通过spring容器获得该bean时总是返回唯一的实例prototype表示每次获得bean都会生成一个新的对象request表示在一次http请求内有效(只适用于web应用)session表示在一个用户会话内有效(只适用于web应用)globalSession表示在全局会话内有效(只适用于...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值