重构增删改查

重构增删改查：

泛型重构：
Object重构和泛型重构的区别：Object需要转换，转换会有异常；
public interface CommonDao<T>{
public Collection<T> getAllEntry();
public T getEntryById(Serializable id);
public void updateEntry(T t);
public void deleteEntry(Serializable id);
public void saveEntry(T t);
}

public class CommonDaoImpl<T> implements ComnonDao<T>{
private HibernateTemplate hibernateTemplate;
//set和get方法
public Collection<T> getAllEntry(){
this.hibernateTemplate.find("from ?");
}
public T getEntryById(Serializable id){
this.hibernateTemplate.get(?,id);
}
public void updateEntry(T t){
this.hibernateTemplate.update(t);
}
public void deleteEntry(Serializable id);
public void saveEntry(T t){
this.hibernateTemplate.save(t);
}
}

接口CommonDao 实现类CommonDaoImpl
接口采用泛型
实现类继承这个接口，可以看到查找需要知道是哪个实体；
这个实现类还需要继承HibernateDaoSupport或者注入HIbernateTemplate；
解决这个泛型的方法是：
public class CommonDaoImpl<T> extends HibernateDaoSupport implements CommonDao<T>{

private Class classt;

public CommonDaoImpl(){
ParameterizedType type = (ParameterizedType)this.getClass().getGenericSuperclass();
this.classt = (Class)type.getActualTypeArguments()[0];
type.getRawType();
}

@Override
public void deleteEntry(Serializable id) {
T t = this.getEntryById(id);
this.getHibernateTemplate().delete(t);
}

@Override
public Collection<T> getAllEntry() {
// TODO Auto-generated method stub
return this.getHibernateTemplate().find("from "+this.classt.getName());
}

@Override
public T getEntryById(Serializable id) {
// TODO Auto-generated method stub
return (T)this.getHibernateTemplate().get(this.classt, id);
}

……
}
java.lang.Type代表java中的所有类型；
泛型是ParameterizedType，也是java中的一种类型；
this.getClass().getGenericSuperclass()

http://blog.sina.com.cn/s/blog_86e34ca8010132ly.html

getGenericSuperclass() 通过反射获取当前类表示的实体（类，接口，基本类型或void）的直接父类的Type，getActualTypeArguments()返回参数数组。
CommonDaoImpl的参数就是那个T；

public CommonDaoImpl(){
//调出泛型
//this.getClass().getGenericSuperclass();就代表CommonDaoImpl<T>
ParameterizedType type = (ParameterizedType)this.getClass().getGenericSuperclass();
this.classt = (Class)type.getActualTypeArguments()[0];//T
type.getRawType()//CommonDaoImpl
----
泛型是ParameterizedType
getActualTypeArguments() 得到参数
getRawType()：得到类和接口
ParameterizedType
Parameterized 参数化
Type一般情况下代表类和接口
@Override
public Collection<T> getAllEntry() {
// TODO Auto-generated method stub
return this.getHibernateTemplate().find("from "+this.classt.getName());
}

@Override
public T getEntryById(Serializable id) {
// TODO Auto-generated method stub
return (T)this.getHibernateTemplate().get(this.classt, id);
}

public interface Type
Type is the common superinterface for all types in the Java programming language. These include raw types, [类或接口]parameterized types,[参数] array types,[数组] type variables[变量] and primitive types[原始类型].
编程最常接触到的是raw types，类和接口；
parameterized types,[参数]

1、类与类与接口之间的传递
1、 public interface Collection<T>{
//
}

2、可以有两种选择
public abstract class AbstractArrayList<T> implements Collection<T>
public abstract class AbstractArrayList implements Collection<Person> //T代表Person
3、可以有两种选择
如果在第二部选择public abstract class AbstractArrayList<T> implements Collection<T>
1、public ArrayList extends AbstrctArrayList<Person> 直接把实参传递给T
2、public ArrayList<T> extends AbstrctArrayList<T>
4、如果在第三步选择了第二个情况，在创建ArrayList对象的时候传递过去
ArrayList<Person> list = new ArrayList<Person>();
2、方法的传递
public <T> T getInstance(Class<T> classt) throws Exception{
return classt.newInstance();
}

由T转为Class，该转换过程写在哪里最好，如果是方法，在每次使用的时候还需要调用；
出发点：不希望子类在创建对象的时候，显示调用该过程
当子类创建对象的时候，要调用父类的默认的构造函数，所以写在父类的构造函数中是最好的选择方式
----
public CommonDaoImpl(){
//调出泛型
//this.getClass().getGenericSuperclass();就代表CommonDaoImpl<T>
ParameterizedType type = (ParameterizedType)this.getClass().getGenericSuperclass();
this.classt = (Class)type.getActualTypeArguments()[0];//T
type.getRawType()//CommonDaoImpl

这里面是this代表的是CommonDaoImpl的继承类，即CommonDaoImpl的子类，getGenericSuperclass代表的是其父类，即是CommonDaoImpl；
CommonDaoImpl是不能有对象的，修饰为abstract， CommonDaoImpl<T,D，E>这里面可以有多个参数，因此这里type.getActualTypeArguments()[0]得到的是T；type.getRawType()//CommonDaoImpl
就是按照两部分记忆：type.getRawType++type.getActualTypeArguments() 类 +参数
如果类是这样"public class CommonDaoImpl<T> extends HibernateDaoSupport implements CommonDao<T>
如果想获得这个实例，必须去掉泛型，否则就会报错；
--
泛型实例化的时候，在有上述代码的情况下，必须加参数
public class CommonDaoImpl<T>
CommonDaoImpl cdi = new CommonDaoImpl();
--
对应CommonDaoImpl的处理
1、不应该把该类写在spring的配置文件中
2、如果写在配置文件中，但是必须在配置文件中关于该类的配置写abstract="true",就是不为该类创建对象
---
方法上的泛型，一般是这样子的，就是知道对应的class
public class DepartmentDaoImpl extends CommonDaoImpl<Department> implements DepartmentDao<Department>{
public <T> T getInstance(Class<T> classt) throws Exception{
return classt.newInstance();
}
}

---
一般报错为java.net.UnknowHostException:struts.apache.org ;这个错误是dtd文件没有找到的问题，url的问题；一般连上网就可以了；或者将本地的dtd文件拷贝就可以了；
---