一个request引发的bug

有很多错误由于需要是多线程是才会发生,导致经常在开发时很难发现,

import java.lang.reflect.ParameterizedType;

import java.util.List;

import javax.servlet.http.HttpServletRequest;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.stereotype.Service;

import org.springframework.web.context.WebApplicationContext;

import org.springframework.web.context.request.RequestContextHolder;

import org.springframework.web.context.request.ServletRequestAttributes;

import org.springframework.web.context.support.WebApplicationContextUtils;

import com.google.gson.Gson;

import com.qdyq.common.criteria.Criteria;

import com.qdyq.common.orm.BaseEntity;

import com.qdyq.common.orm.BaseMapper;

import com.qdyq.common.orm.MySqlSessionFactoryBean;

import qdyq.api.service.CommonService;

import qdyq.api.service.exception.MapperNameErrorException;

@Service("common")

@SuppressWarnings({ "rawtypes", "unchecked" })

public class CommonServiceImpl implements CommonService {

    //private String entityName;

    private ThreadLocal<String> entityNameSafe = new ThreadLocal<String>();

    @Autowired

    private MySqlSessionFactoryBean sqlSessionFactory;

    public List list(Criteria criteria) {

        BaseMapper mapper = getMapper();

        System.out.println(mapper.getClass().getName());

        return mapper.getBy(criteria);

    }

    public BaseEntity getById(Long id) {

        BaseMapper mapper = getMapper();

        return mapper.getById(id);

    }

    public int save(String entityJson) {

        BaseMapper mapper = getMapper();

        BaseEntity entity = (BaseEntity) new Gson().fromJson(entityJson, this.getEntityClass());

        if(entity==null){

            System.err.println(Thread.currentThread().getId() + entityJson + this.entityNameSafe.get());

        }

        if (entity.getId() == null)

            return mapper.insert(entity);

        else

            return mapper.update(entity);

    }

    public int save(BaseEntity entity) {

        this.setEntityName(entity.getClass().getSimpleName());

        BaseMapper mapper = getMapper();

        System.err.println(mapper.getClass().getName() + Thread.currentThread().getId());

        if (entity.getId() == null)

            return mapper.insert(entity);

        else

            return mapper.update(entity);

    }

    public int countBy(Criteria criteria) {

        BaseMapper mapper = getMapper();

        return mapper.countBy(criteria);

    }

    public void setEntityName(String entityName) {

        this.entityNameSafe.set(entityName);

        //this.entityName = entityName;

    }

    public Class getEntityClass() {

        String daoName = this.sqlSessionFactory.getPkgName() + "." + this.entityNameSafe.get() + "Dao";

        Class daoInterface;

        try {

            daoInterface = Class.forName(daoName);

            return (Class) ((ParameterizedType) daoInterface.getGenericInterfaces()[0]).getActualTypeArguments()[0];

        } catch (ClassNotFoundException e) {

            throw new MapperNameErrorException("无效的entityName" + daoName, e, daoName);

        } catch (Exception e) {

            throw new MapperNameErrorException("未注册的entityName" + daoName, e, daoName);

        }

    }

    public List listAss(Criteria criteria) {

        BaseMapper mapper = getMapper();

        return mapper.getAssBy(criteria);

    }

    public List all() {

        BaseMapper mapper = getMapper();

        return mapper.findAll();

    }

    public int delete(Object[] id) {

        BaseMapper mapper = getMapper();

        return mapper.deleteByIds(id);

    }

    protected BaseMapper getMapper(){

        String daoName = this.sqlSessionFactory.getPkgName() + "." + this.entityNameSafe.get() + "Dao";

        Class daoInterface;

        System.err.println(daoName + Thread.currentThread().getId());

        HttpServletRequest request = null;

        try{

            daoInterface = Class.forName(daoName);

            request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();

            WebApplicationContext context = WebApplicationContextUtils.getWebApplicationContext(request.getSession().getServletContext());

            return (BaseMapper) context.getBean(daoInterface);

        }catch(Exception e){

            throw new RuntimeException("无法获取到mapper:" + this.entityNameSafe.get());

        }

    }

    public int saveAll(List<BaseEntity> list) {

        BaseMapper mapper = getMapper();

        return mapper.insertAll(list);

    }

    public int removeBy(Criteria criteria){

        BaseMapper mapper = getMapper();

        return mapper.removeBy(criteria);

    }

    public static void main(String[] args){

        //String json = "{id:485,lastTraceDate:'2017-11-09T10:20:37.293Z'}";

    }

}

这是一个公共的类,能满足一般的增删改查功能,通过参数,entityName来确定具体使用哪个mapper来完成任务,mapper只要有一个公共的基类,就可以实现上述

功能,但是由于网络请求是多线程的,所以及易导致entityName的冲突,因为原先的entityName只是一个本地字符串,而springmvc的对象又是单例的,这就导致错误的发生

ThreadLocal<String>是一种解决办法,第二种办法是把该对象配置成原型模式,也可以避免错误的发生.

既然类成员变量容易导致错误,哪么request会不会导致错误,因为这次错误引起了思考果断做了测试,

@ResponseBody

    @RequestMapping(value = "/save/{entityName}", method = RequestMethod.POST)

    public Object save(@PathVariable String entityName, String entityJson,HttpServletRequest request) {

        this.getService().setEntityName(entityName);

        System.err.println("============================");

        System.err.println(request.hashCode());

        System.err.println(this.request.hashCode());

        System.err.println(this.request.getParameter("entityJson"));

        System.err.println(this.request.getClass().getName());

        System.err.println(request.getClass().getName());

        System.err.println("============================");

        return getService().save(entityJson);

    }

this.request是通过@Autowired注入的,打印结果到显示this.request始终是一个对象,但是它的获取结果却始终都是正确的,因为它并不是一个对象而是一个代理,也就是说它是线程安全的.但是作为参数传进来的request就不是线程安全的,如果你把它保存在一个成员变量里,后果是很严重的,因为使用过期的request会导致现有request参数的丢失,具体原因还不太清楚,感觉应该是request这个对象里使用缓存之类的东西造成的.