基础类的收集

在开发中常用到的基础类：

RetMsg.java:

**
* 返回业务层的结果处理对象
*/
public class RetMsg<T> implements java.io.Serializable {

private static final long serialVersionUID = 1L;

private boolean success;
private String msg;
private T obj;
private List<T> list;

public boolean isSuccess() {
return success;
}
public void setSuccess(boolean success) {
this.success = success;
}
public String getMsg() {
return msg;
}
public void setMsg(String msg) {
this.msg = msg;
}
public T getObj() {
return obj;
}
public void setObj(T obj) {
this.obj = obj;
}
public List<T> getList() {
return list;
}
public void setList(List<T> list) {
this.list = list;
}
@Override
public String toString() {
return "RetMsg [success=" + success + ", msg=" + msg + ", obj=" + obj
+ ", list=" + list + "]";
}
}

 

其中T代表的含义是：

这个方法涉及到两个知识点：
1）泛型
2）扩展方法

先抛开“扩展方法”不提，这个方法属于“泛型方法”（注意：不是泛型类）。
以下为简单示例：
public static T ToString<T>(T obj)
{
      return obj.ToString();
}
假设调用：
ToString<int>(2);
等效于：
public static int ToString(int obj)  // 原来的 T 被替换为 int 
{ return obj.ToString(); }

假设调用
ToString<string>("MyString");
等效于：
public static string ToString(string obj)  // 原来的 T 被替换为 string 
{  return obj.ToString(); }

通过以上例子可以看出，泛型参数 T 其实就是一个“类型占位符”，在编译时或运行时动态的替换为实际数据类型。我想你现在可以大致理解泛型方法了吧？
最后备注：where T : class 表示约束泛型参数 T 必须是引用类型，不能是值类型。

扩展方法：
是指在某个类型上，扩展出一个方法（属于编译技术，俗称：语法糖）。
CloneObject<T>(this T obj) 意思，是指在类型 T 上扩展一个 CloneObject 方法。
这个 T 是泛型参数：
1）如果泛型参数是 string 则表示在 string 上扩展 CloneObject 方法
2）如果泛型参数是 ArrayList 则表示在 ArrayList 上扩展 CloneObject 方法
3）如果泛型参数是其它 XXXXX 类，则表示在 XXXXX 类上扩展 CloneObject 方法

常量配置：
java 常量就是不变的值，在JAVA中就用final关键字来标识，主要作用是为了更方便的让很多人使用变量，易于维护。
static就是静态变量，声明为static的变量实质上就是全局变量，如果一个成员被声明为static，它就能够在它的类的任何对象创建之前被访问，而不必引用任何对象！
static类中只能有静态成员，可以理解为是静态变量的集合！
如果在方法前面加static关键字，则表示为静态方法。
声明为static的方法有以下几条限制：
1、它们仅能调用其他的static 方法。 
2、它们只能访问static数据。 
3、它们不能以任何方式引用this 或super

import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionTemplate;
import org.mybatis.spring.support.SqlSessionDaoSupport;
import org.springframework.beans.factory.annotation.Autowired;
import javax.annotation.Resource;
import java.io.Serializable;
/**
 * mybatis dao基础类，提供实体类的CRUD基本功能
 * @param <T> 实体类的类型
 * @param <PK> 主键类的类型
 */
public abstract class SimpleMybatisSupport<T, PK extends Serializable> extends SqlSessionDaoSupport{

    protected final String baseNamesapce = "cn.ffcs.server.dao.mapper";
    @Autowired
    public void setSqlSessionTemplate(SqlSessionTemplate sqlSessionTemplate) {
        super.setSqlSessionTemplate(sqlSessionTemplate);
    }

    public int deleteByPrimaryKey(PK id) {
        return getSqlSession().delete(toMybatisStatement("deleteByPrimaryKey"), id);
    }
    public int insert(T record) {
        return getSqlSession().insert(toMybatisStatement("insert"), record);
    }

    public int insertSelective(T record) {
        return getSqlSession().insert(toMybatisStatement("insertSelective"), record);
    }

    @SuppressWarnings("unchecked")
    public T selectByPrimaryKey(PK id) {
        return (T)getSqlSession().selectOne(toMybatisStatement("selectByPrimaryKey"),id);
    }

    public int updateByPrimaryKey(T record) {
        return getSqlSession().update(toMybatisStatement("updateByPrimaryKey"), record);
    }

    public int updateByPrimaryKeySelective(T record) {
        return getSqlSession().update(toMybatisStatement("updateByPrimaryKeySelective"), record);
    }

    public String toMybatisStatement(String statementName) {
        return getMybatisMapperNamesapce() + "." + statementName;
    }

    public abstract String getMybatisMapperNamesapce();

    @Resource
    public void setSqlSessionFactory(SqlSessionFactory sqlSessionFactory){
        super.setSqlSessionFactory(sqlSessionFactory);
    }
}

异常处理： 

这是处理没法进一步处理的异常的一般做法。try块中出现了一个异常，它被catch住了，我们首先要在标准输出上打印出异常但是如果没有throw这句，这个错误就静悄悄地被catch块吃掉了，程序会继续运行。可这个时候很可能你的程序的状态已经不对了，继续下去也没有什么意义，所以应该继续抛出这个异常。你当然可以写throw e;，但是这个e是一般的异常，如果这样抛出的话，你得在这个函数头上用throws来声明，比如：
public void abc() throws Exception
然后调用这个函数的函数也还得这么干，所以一般的处理是把e包装成运行时异常：new RuntimeException(e)，这样就不需要在函数头声明了。但这只是一般的处理方法，在实际程序中不可不顾实际情况和需求生搬硬套。