@liayun 2016-09-20T14:24:22.000000Z 字数 9579 阅读 1679

注解(二)——解析注解案例

java基础加强

注解入门后，还不趁火打铁，将注解的应用弄得炉火纯青，更待何时。我们通过3个例子来详解注解在实际开发中的应用。

解析注解的简单案例

我们首先关注一个解析注解的简单案列，由简入难，循序渐进，最后过渡到非常复杂的案例中。
在实际项目中，我们通常需要编写一个JdbcUtils的工具类，用于得到与数据库的连接，而与数据库相关的基本配置信息我们通常是用一个配置文件来存储的，但现在我们希望用一个注解来替代配置文件。接下来就是我们所要详解的一个解析注解的简单案列——通过注解来给类注入一些基本信息进去。
首先我们编写一个注解——DbInfo：

@Retention(RetentionPolicy.RUNTIME)
public @interface DbInfo {
    String driver();
    String url();
    String username();
    String password();
}

千万要注意：当一个Annotation类型被定义为运行时Annotation后，该注释才是运行时可见，当class文件被载入时保存在class文件中的Annotation才会被虚拟机读取。所以对于注解DbInfo来说，@Retention(RetentionPolicy.RUNTIME)元注解不能丢失，否则会报java.lang.NullPointerException异常。
接着我们就编写JdbcUtils工具类，由于是第一次编写，代码可能会是这样：

public class JdbcUtils {
    @DbInfo(driver="com.mysql.jdbc.Driver", url="jdbc:mysql://localhost:3306/bookstore", username="root", password="yezi")
    public static Connection getConnection() {
        try {
            Method method = JdbcUtils.class.getMethod("getConnection", null); // 反射出getConnection()方法
            DbInfo info = method.getAnnotation(DbInfo.class); // 得到@DbInfo(...)注解
            String driver = info.driver();
            String url = info.url();
            String username = info.username();
            String password = info.password();
            System.out.println(driver);
            System.out.println(url);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
    public static void main(String[] args) {
        JdbcUtils.getConnection();
    }
}

虽然上面的程序运行没问题，但还是不够优雅，因为注解DbInfo只需要解析一次，所以我们可以在JdbcUtils工具类被加载时就解析该注解。这样该工具类的代码就应为：

public class JdbcUtils {
    private static String driver;
    private static String url;
    private static String username;
    private static String password;
    static {
        try {
            // 解析注解，获取注解配置的信息
            Method method = JdbcUtils.class.getMethod("getConnection", null); // 反射出getConnection()方法
            DbInfo info = method.getAnnotation(DbInfo.class); // 得到@DbInfo(...)注解
            driver = info.driver();
            url = info.url();
            username = info.username();
            password = info.password();
        } catch (Exception e) {
            throw new RuntimeException(e);
        } 
    }
    @DbInfo(driver="com.mysql.jdbc.Driver", url="jdbc:mysql://localhost:3306/bookstore", username="root", password="yezi")
    public static Connection getConnection() {
        System.out.println(driver);
        System.out.println(url);
        return null;
    }
    public static void main(String[] args) {
        JdbcUtils.getConnection();
    }
}

这样代码看起来还算优雅吧！！！
接下来，我们就要昂首踏步地进入解析注解的超复杂的案例中了。

解析注解的复杂案例

我们在做开发的时候，经常会碰到注解加到字段上或者方法上，结果这个类就会自动拥有某个对象。我们不禁要问，这是怎么一回事呢？为了弄明白，我们宁可花费大量的精力去深度剖析其内部的原理，这将对我们以后学习框架具有极大的帮助。我们首先关注加到方法上的注解。

解析方法上的注解

一个项目中会有很多实体类型，那么我们就要编写多个相对应的Dao，比如在工程中有这样一个实体类型——Book.java：

public class Book implements Serializable {
    blabla...
}

那么我们就要编写其对应的Dao——BookDao.java去操作数据库，为了提升程序的数据库访问性能，我们决定在应用程序中加入C3P0连接池，所以在该工程中应导入如下Jar包：

c3p0-0.9.5.2.jar
mchange-commons-java-0.2.11.jar
mysql-connector-java-5.1.38-bin.jar

在编写BookDao类的过程中，为了简化对JDBC的编写，我们就不可避免地要使用Apache组织提供的一个开源JDBC工具类库——commons-dbutils。那么这时BookDao类的代码可以写成：

public class BookDao {
    public void add(Book book) {
        QueryRunner runner = new QueryRunner(...);
        blabla...
    }
}

在编写该类的过程中，我们发现QueryRunner类需要一个javax.sql.DataSource来作参数的构造方法。要想得到QueryRunner类的一个实例对象，必须传递一个数据库连接池进去。这样BookDao类的代码就应是这样：

public class BookDao {
    private ComboPooledDataSource ds;
    public void setDs(ComboPooledDataSource ds) {
        this.ds = ds;
    }
    public ComboPooledDataSource getDs() {
        return ds;
    }
    public void add(Book book) {
        QueryRunner runner = new QueryRunner(ds);
        blabla...
    }
}

一般来说，我们在应用程序中加入C3P0连接池后，都要在类目录下加入C3P0的配置文件——c3p0-config.xml，里面配置的是与数据库相关的信息。但是我们已经学过注解了，而注解就是用于替代配置文件，所以在该工程中我们打算用注解。
BookDao类在工作的时候需要一个连接池ds，那我就要在public void setDs(ComboPooledDataSource ds)方法上加入一个注解，注解起的作用是注入拥有些许属性的连接池进来，即通过注解注入对象。这样，我们编写的注解就应该是：

@Retention(RetentionPolicy.RUNTIME)
public @interface Inject {
    String driverClass() default "com.mysql.jdbc.Driver";
    String jdbcUrl() default "jdbc:mysql://localhost:3306/bookstore";
    String user() default "root";
    String password() default "yezi";
}

Inject注解写完之后，BookDao类的代码就要改成：

public class BookDao {
    /*
     * 任何类都是Object的孩子，也即BookDao这个类从Object类还继承了class属性
     */
    private ComboPooledDataSource ds;
    @Inject
    public void setDs(ComboPooledDataSource ds) {
        this.ds = ds;
    }
    public ComboPooledDataSource getDs() {
        return ds;
    }
    public void add(Book book) {
        QueryRunner runner = new QueryRunner(ds);
        blabla...
    }
}

现在我们就要写一个解析程序来解析这个注解，通过注解的配置信息来配置一个连接池进来。那这个解析程序的代码写在哪儿呢？——BookDao类是由service层来调用的，一般service层会通过一个工厂去创建Dao，那么在由工厂创建Dao的时候，负责解析这个注解，给创建的Dao配置一个连接池进去。也即这时我们要编写一个DaoFactory类。

public class DaoFactory {
    public static BookDao createBookDao() {
        BookDao dao = new BookDao();
        // 向dao注入一个连接池
        blabla......
        return dao;     
    }
}

如何向dao注入一个连接池呢？——我的思路是这样的：我首先会反射出BookDao类的所有属性，我看哪个属性的set方法上有注解，并且判断它这个方法上是不是要一个Inject注解，若是就用这个注解配置的信息来创建一个连接池，并注入进来。
大家可能有一个疑问，那就是为什么要反射出BookDao类的所有属性呢，我们只需要反射出ds这个属性，看该属性的set方法上有没注解即可了吧？原因是我们写的DaoFactory类要具有通用性，试想如果还有一个CategoryDao类。

public class CategoryDao {
    private ComboPooledDataSource combods;
    @Inject
    public void setCombods(ComboPooledDataSource combods) {
        this.combods = combods;
    }
}

该CategoryDao类的combods属性的set方法上才有注解。若想我们编写的DaoFactory类具有通用性，那么必须得反射出BookDao类的所有属性。
注意：虽然我们要反射出BookDao类的所有属性，但是父类的属性我们是不要的哟，因为任何类都是Object的孩子，也即BookDao这个类从Object类还继承了class属性，所以该class属性是没必要解析出来的。
走到这一步，接下来我们就要编写出完整的DaoFactory类了。

public class DaoFactory {
    public static BookDao createBookDao() {
        BookDao dao = new BookDao();
        // 向dao注入一个连接池
        try {
            // 解析出dao所有的属性，父类(Object)的属性我不要(用内省技术)
            BeanInfo info = Introspector.getBeanInfo(dao.getClass(), Object.class);
            PropertyDescriptor[] pds = info.getPropertyDescriptors();
            for (int i = 0; pds != null && i < pds.length; i++) {
                // 得到bean的每一个属性描述器
                PropertyDescriptor pd = pds[i];
                Method setMethod = pd.getWriteMethod(); // 得到属性对应的set方法 
                // 看set方法上有没有Inject注解
                Inject inject = setMethod.getAnnotation(Inject.class);
                if (inject == null) {
                    continue;
                }
                // 若方法上有Inject注解，则用注解配置的信息创建一个连接池
                DataSource ds = createDataSourceByInject(inject, new ComboPooledDataSource());
                setMethod.invoke(dao, ds); // 用注解配置的信息创建出一个连接池之后，往dao注入进去
            }
        } catch (Exception e) {
            throw new RuntimeException(e);
        } 
        return dao;     
    }
    // 用注解的信息，为连接池配置属性
    private static DataSource createDataSourceByInject(Inject inject, DataSource ds) { // 传递进来的有可能是DBCP池，也有可能是C3P0池，这两个池的属性是不一样的，但是我们的代码要通用！
        // 获取到注解所有属性相应的方法，driverClass、url、equals、hashCode方法
        Method[] methods = inject.getClass().getMethods();
        for (Method m : methods) {
            String methodName = m.getName(); // 得到方法名，如equals、url
            PropertyDescriptor pd = null;
            try {
                /*
                 * ds池上面有没有这个方法名对应的属性，又要通过内省技术
                 * 现在用属性描述器去描述ds.getClass()这个Class上面有没有这个方法名对应的属性，
                 * 若没有，就会抛异常，否则要继续下一轮循环。
                 */
                pd = new PropertyDescriptor(methodName, ds.getClass()); // getEquals、getUrl
                Object value = m.invoke(inject, null); // 得到注解属性的值
                pd.getWriteMethod().invoke(ds, value); // 得到注解属性的值之后，要把这个值set到连接池相对应的属性上
            } catch (Exception e) {
                continue;
            } 
        }
        return ds;
    }
}

编写好了上面的DaoFactory类的代码之后，我们就要测试其好不好使。

public class TestFactory {
    public static void main(String[] args) throws SQLException {
        BookDao dao = DaoFactory.createBookDao();
        DataSource ds = dao.getDs();
        Connection conn = ds.getConnection();
        System.out.println(conn);
    }
}

测试通过，没问题。其实如果我们足够细心的话，可以发现我们上面编写的DaoFactory类依然不够通用，问题出在代码

DataSource ds = createDataSourceByInject(inject, new ComboPooledDataSource());

处，因为现在我们是自己new了一个连接池，但是我们是不应该new的，做的好的话，应该是我这个BookDao内省出所有的属性，内省出所有的属性之后，我看这个属性类型是什么，就应该创建一个什么样的连接池。这样真正具有通用性的DaoFactory类的代码为：

public class DaoFactory {
    public static BookDao createBookDao() {
        BookDao dao = new BookDao();
        // 向dao注入一个连接池
        try {
            // 解析出dao所有的属性，父类(Object)的属性我不要(用内省技术)
            BeanInfo info = Introspector.getBeanInfo(dao.getClass(), Object.class);
            PropertyDescriptor[] pds = info.getPropertyDescriptors();
            for (int i = 0; pds != null && i < pds.length; i++) {
                // 得到bean的每一个属性描述器
                PropertyDescriptor pd = pds[i];
                Method setMethod = pd.getWriteMethod(); // 得到属性对应的set方法 
                // 看set方法上有没有Inject注解
                Inject inject = setMethod.getAnnotation(Inject.class);
                if (inject == null) {
                    continue;
                }
                // 若方法上有Inject注解，则用注解配置的信息创建一个连接池
                Class propertyType = pd.getPropertyType(); // 获取属性描述器描述的那个属性的类型
                Object datasource = propertyType.newInstance(); // 创建出这个属性需要内省的那个对象，即整出了一个连接池
                DataSource ds = (DataSource) createDataSourceByInject(inject, datasource); 
                setMethod.invoke(dao, ds); // 用注解配置的信息创建出一个连接池之后，往dao注入进去
            }
        } catch (Exception e) {
            throw new RuntimeException(e);
        } 
        return dao;     
    }
    // 用注解的信息，为连接池配置属性
    private static DataSource createDataSourceByInject(Inject inject, DataSource ds) { // 传递进来的有可能是DBCP池，也有可能是C3P0池，这两个池的属性是不一样的，但是我们的代码要通用！
        // 获取到注解所有属性相应的方法，driverClass、url、equals、hashCode方法
        Method[] methods = inject.getClass().getMethods();
        for (Method m : methods) {
            String methodName = m.getName(); // 得到方法名，如equals、url
            PropertyDescriptor pd = null;
            try {
                /*
                 * ds池上面有没有这个方法名对应的属性，又要通过内省技术
                 * 现在用属性描述器去描述ds.getClass()这个Class上面有没有这个方法名对应的属性，
                 * 若没有，就会抛异常，否则要继续下一轮循环。
                 */
                pd = new PropertyDescriptor(methodName, ds.getClass()); // getEquals、getUrl
                Object value = m.invoke(inject, null); // 得到注解属性的值
                pd.getWriteMethod().invoke(ds, value); // 得到注解属性的值之后，要把这个值set到连接池相对应的属性上
            } catch (Exception e) {
                continue;
            } 
        }
        return ds;
    }
}

接下来，我们就来关注加到字段上的注解。

解析字段上的注解

我们在做开发的时候，也有会碰到注解加到字段上的情况。如：

public class BookDao {
    /*
     * 任何类都是Object的孩子，也即BookDao这个类从Object类还继承了class属性
     */
    @Inject private ComboPooledDataSource ds; // 字段
    @Inject
    public void setDs(ComboPooledDataSource ds) {
        this.ds = ds;
    }
    public ComboPooledDataSource getDs() {
        return ds;
    }
    public void add(Book book) {
        QueryRunner runner = new QueryRunner(ds);
        blabla......
    }
}

同理，现在我们就要写一个解析程序来解析字段上的注解，通过注解的配置信息来配置一个连接池进来。这样我们的DaoFactory类的代码可以写为：

public class DaoFactory {
    public static BookDao createBookDao() {
        BookDao dao = new BookDao();
        Field[] fields = dao.getClass().getDeclaredFields();
        for (int i = 0; fields != null && i < fields.length; i++) {
            Field f = fields[i];
            f.setAccessible(true);
            Inject inject = f.getAnnotation(Inject.class);
            if (inject == null) {
                continue;
            }
            // 代表当前获取到的字段上有Inject这个注解，则用注解的配置信息，创建一个连接池赋到字段上
            try {
                DataSource ds = (DataSource) f.getType().newInstance(); // 获取字段的类型，创建字段需要的连接池
                // 用注解的信息，配置上面创建的连接池
                inject2Datasource(inject, ds);
                f.set(dao, ds); // 调用字段的set方法把这个连接池设置到dao上去
            } catch (Exception e) {
                e.printStackTrace();
            } 
        }
        return dao;
    }
    // 用注解的信息，配置连接池
    private static void inject2Datasource(Inject inject, DataSource ds) {
        Method[] methods = inject.getClass().getMethods();
        for (Method method : methods) {
            String name = method.getName(); // 得到注解的每一个方法，例如(jdbcUrl()、user()、password()、toString()、equals()、hashCode()...)
            // 获取ds上与方法名相对应的属性
            try {
                PropertyDescriptor pd = new PropertyDescriptor(name, ds.getClass());
                Object value = method.invoke(inject, null); // 得到注解属性的值
                // 把值赋到ds的属性上
                pd.getWriteMethod().invoke(ds, value);
            } catch (Exception e) {
                continue;
            }
        }
    }
}

总结

将来在做开发的时候，经常会发现你写好一个类，只需要往字段上或方法上加上一个注解，再把这个类交给某个容器(例如Spring)管理，结果那个容器就会自动帮你注入一个对象，你那个时候就不需要自己傻逼兮兮地创建对象了。