• 基础类的收集


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

    RetMsg.java:

     1 **
     2 * 返回业务层的结果处理对象
     3 */
     4 public class RetMsg<T> implements java.io.Serializable {
     5 
     6 private static final long serialVersionUID = 1L;
     7 
     8 private boolean success;
     9 private String msg;
    10 private T obj;
    11 private List<T> list;
    12 
    13 public boolean isSuccess() {
    14 return success;
    15 }
    16 public void setSuccess(boolean success) {
    17 this.success = success;
    18 }
    19 public String getMsg() {
    20 return msg;
    21 }
    22 public void setMsg(String msg) {
    23 this.msg = msg;
    24 }
    25 public T getObj() {
    26 return obj;
    27 }
    28 public void setObj(T obj) {
    29 this.obj = obj;
    30 }
    31 public List<T> getList() {
    32 return list;
    33 }
    34 public void setList(List<T> list) {
    35 this.list = list;
    36 }
    37 @Override
    38 public String toString() {
    39 return "RetMsg [success=" + success + ", msg=" + msg + ", obj=" + obj
    40 + ", list=" + list + "]";
    41 }
    42 }
    43 
    44  

    其中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


     2 import org.apache.ibatis.session.SqlSessionFactory;
     3 import org.mybatis.spring.SqlSessionTemplate;
     4 import org.mybatis.spring.support.SqlSessionDaoSupport;
     5 import org.springframework.beans.factory.annotation.Autowired;
     6 import javax.annotation.Resource;
     7 import java.io.Serializable;
     8 /**
     9  * mybatis dao基础类,提供实体类的CRUD基本功能
    10  * @param <T> 实体类的类型
    11  * @param <PK> 主键类的类型
    12  */
    13 public abstract class SimpleMybatisSupport<T, PK extends Serializable> extends SqlSessionDaoSupport{
    14 
    15     protected final String baseNamesapce = "cn.ffcs.server.dao.mapper";
    16     @Autowired
    17     public void setSqlSessionTemplate(SqlSessionTemplate sqlSessionTemplate) {
    18         super.setSqlSessionTemplate(sqlSessionTemplate);
    19     }
    20 
    21     public int deleteByPrimaryKey(PK id) {
    22         return getSqlSession().delete(toMybatisStatement("deleteByPrimaryKey"), id);
    23     }
    24     public int insert(T record) {
    25         return getSqlSession().insert(toMybatisStatement("insert"), record);
    26     }
    27 
    28     public int insertSelective(T record) {
    29         return getSqlSession().insert(toMybatisStatement("insertSelective"), record);
    30     }
    31 
    32     @SuppressWarnings("unchecked")
    33     public T selectByPrimaryKey(PK id) {
    34         return (T)getSqlSession().selectOne(toMybatisStatement("selectByPrimaryKey"),id);
    35     }
    36 
    37     public int updateByPrimaryKey(T record) {
    38         return getSqlSession().update(toMybatisStatement("updateByPrimaryKey"), record);
    39     }
    40 
    41     public int updateByPrimaryKeySelective(T record) {
    42         return getSqlSession().update(toMybatisStatement("updateByPrimaryKeySelective"), record);
    43     }
    44 
    45     public String toMybatisStatement(String statementName) {
    46         return getMybatisMapperNamesapce() + "." + statementName;
    47     }
    48 
    49     public abstract String getMybatisMapperNamesapce();
    50 
    51     @Resource
    52     public void setSqlSessionFactory(SqlSessionFactory sqlSessionFactory){
    53         super.setSqlSessionFactory(sqlSessionFactory);
    54     }
    55 }

    异常处理: 

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

    
    


  • 相关阅读:
    jenkins(5): jenkins邮件报警配置
    Hive(二)—— 架构设计
    Flume(三) —— 断点续传 与 事务
    Flume(二) —— 自定义拦截器、Source、Sink
    Canal —— 基本概念及使用
    Kafka(五) —— Kafka源码本地调试
    Hadoop(五)—— HDFS NameNode、DataNode工作机制
    Cloudera-Manage —— 基本概念及使用
    【系统设计&解决方案】秒杀系统设计
    HBase(一) —— 基本概念及使用
  • 原文地址:https://www.cnblogs.com/zjITgrow/p/6077053.html
Copyright © 2020-2023  润新知