泛型接口

泛型接口，废话不多说直接上代码

BaseService<T>泛型接口，这里可以使得子类拥有自己的类型 T

//这个就是我们的泛型接口
public interface BaseService<T> {
    public void save(T t);
    public void update(T t);
    public T get(int id);
    public List<T> query();
    public void delete(int id);
}

BaseServiceImpl<T>泛型接口的实现类，这里我们有一个构造方法，构造方法中，由于是子类来进行构造，因此我们先获取当前Class，然后在获取父类对象，又因为父类对象是参数化对象(何为参数化对象BaseService<T>这就是参数化对象),然后通过参数化对象的 getActualTypeArguments()方法获取到所有参数类型，也就是我们的泛型参数

public class BaseServiceImpl<T> implements BaseService<T> {

    //使用hibernateTemplate
    protected HibernateTemplate hibernateTemplate = null;
    
    public void setHibernateTemplate(HibernateTemplate hibernateTemplate) {
        this.hibernateTemplate = hibernateTemplate;
    }
    //父类事例
    private Class<T> clazz = null;
    
    protected BaseServiceImpl() {
        //获取当前类的父类---------使用反射，因为我们是泛型接口，因此需要反射来获取父类事例
        //参数化类型-----      通过得到父类，然后得到父类的泛型，也就是参数化类型，然后[0]
        ParameterizedType type = (ParameterizedType) this.getClass().getGenericSuperclass();
        clazz = (Class<T>) type.getActualTypeArguments()[0];
    }

    @Override
    public void save(T t) {
        hibernateTemplate.save(t);
    }

    @Override
    public void update(T t) {
        hibernateTemplate.update(t);
    }

    @Override
    public T get(int id) {
        return (T) hibernateTemplate.get(clazz, id);
    }

    @Override
    public List<T> query() {
        return hibernateTemplate.find("FROM"+clazz.getSimpleName());
    }

    @Override
    public void delete(int id) {
        Object o = hibernateTemplate.get(clazz, id);
        if(o != null){
            hibernateTemplate.delete(o);
        }
    }
   
}

　AccountService<T>

public interface AccountService<Account> extends BaseService<T> {
    //业务逻辑            登录
    public T login(T account);
}

AccountServiceImpl 这就是我们的具体实现类，

public class AccountServiceImpl extends BaseServiceImpl<Account>
        implements
            AccountService {

    @Override
    public Account login(Account account) {
        List<Account> accounts = hibernateTemplate.findByNamedParam(
                "FROM Account a WHERE a.alogin=:alogin AND a.apass=:apass",
                new String[]{"alogin", "apass"},
                new Object[]{account.getAlogin(), account.getApass()});
        return accounts != null ? accounts.get(0) : null;
    }
}

为很么我的要写这么多代码呢？

就是因为下面代码出问题了

我在spring配置文件中配置了

    <bean id="accountServiceImpl" class='com.czd.shopping.service.impl.AccountServiceImpl'>
        <property name="hibernateTemplate" ref="hibernateTemplate" />
    </bean>

然后在测试中

//转型失败
(AccountServiceImpl)context.getBean("accountServiceImpl");
//转型成功
(AccountService)context.getBean("accountServiceImpl");

|

|

|

|

懊恼了半天，最后才发现原来是自己已经将Service配置了事务代理，我们又使用的是接口的代理方式

    <tx:advice id="advice" transaction-manager="transactionManager">
        <tx:attributes>
            <tx:method name="save*" propagation="REQUIRED"/>
            <tx:method name="delete*" propagation="REQUIRED"/>
            <tx:method name="update*" propagation="REQUIRED"/>
            <tx:method name="*" propagation="NEVER" read-only="true"/>
        </tx:attributes>
    </tx:advice>
    <!-- 5  -->
    <!-- 使用aop 来进行指定的 连接点 进行增强 -->
    <aop:config>
        <!-- 一定要注意expression的写法以及空格 -->
        <aop:pointcut expression="execution(* com.czd.shopping.service.impl.*.*(..))" id="pointcut"/>
        <aop:advisor advice-ref="advice" pointcut-ref="pointcut"/>
    </aop:config>

因此我们这里就是基于jdk动态接口代理，代理类跟我们的原实例类肯定不是一个对象，因此我们只能转型到接口。

这里我学到了如何使用泛型接口，并且解决了一个问题！！！！！！！！！给自己加油