1. /**
    2.  * 用于封装执行的SQL语句和结果类型的全限定类名
    3.  */
    4. public class Mapper {
    5.     private String queryString;//SQL
    6.     private String resultType;//全限定实体类名称
    8.     public String getQueryString() {
    9.         return queryString;
    10.     }
    12.     public void setQueryString(String queryString) {
    13.         this.queryString = queryString;
    14.     }
    16.     public String getResultType() {
    17.         return resultType;
    18.     }
    20.     public void setResultType(String resultType) {
    21.         this.resultType = resultType;
    22.     }
    23. }

    配置类

    1. /**
    2.  * mybatis的配置类
    3.  */
    4. public class Configuration {
    5.     private String driver;
    6.     private String url;
    7.     private String username;
    8.     private String password;
    9.     private Map<String,Mapper> mappers = new HashMap<String,Mapper>();
    11.     public Map<String, Mapper> getMappers() {
    12.         return mappers;
    13.     }
    15.     public void setMappers(Map<String, Mapper> mappers) {
    16.         System.out.println(mappers);
    17.         this.mappers.putAll(mappers);// 追加
    18.     }
    20.     public String getDriver() {
    21.         return driver;
    22.     }
    24.     public void setDriver(String driver) {
    25.         this.driver = driver;
    26.     }
    28.     public String getUrl() {
    29.         return url;
    30.     }
    32.     public void setUrl(String url) {
    33.         this.url = url;
    34.     }
    36.     public String getUsername() {
    37.         return username;
    38.     }
    40.     public void setUsername(String username) {
    41.         this.username = username;
    42.     }
    44.     public String getPassword() {
    45.         return password;
    46.     }
    48.     public void setPassword(String password) {
    49.         this.password = password;
    50.     }
    51. }

    注解

    1. import java.lang.annotation.ElementType;
    2. import java.lang.annotation.Retention;
    3. import java.lang.annotation.RetentionPolicy;
    4. import java.lang.annotation.Target;
    6. @Retention(RetentionPolicy.RUNTIME)
    7. @Target(ElementType.METHOD)
    8. public @interface Select {
    9.     String value();
    10. }

    数据库工具类

    1. /**
    2.  * 用于创建数据源的工具类
    3.  */
    4. public class DataSourceUtil {
    6.     /**
    7.      * 用于获取一个连接
    8.      * @param cfg
    9.      * @return
    10.      */
    11.     public static Connection getConnection(Configuration cfg){
    12.         try {
    13.             Class.forName(cfg.getDriver());
    14.             return DriverManager.getConnection(cfg.getUrl(), cfg.getUsername(), cfg.getPassword());
    15.         }catch(Exception e){
    16.             throw new RuntimeException(e);
    17.         }
    18.     }
    19. }

    负责执行SQL语句，并且封装结果集

    1. /**
    2.  * 负责执行SQL语句，并且封装结果集
    3.  */
    4. public class Executor {
    6.     public <E> List<E> selectList(Mapper mapper, Connection conn) {
    7.         PreparedStatement pstm = null;
    8.         ResultSet rs = null;
    9.         try {
    10.             //1.取出mapper中的数据
    11.             String queryString = mapper.getQueryString();//select * from user
    12.             String resultType = mapper.getResultType();//com.itheima.domain.User
    13.             Class domainClass = Class.forName(resultType);
    14.             //2.获取PreparedStatement对象
    15.             pstm = conn.prepareStatement(queryString);
    16.             //3.执行SQL语句，获取结果集
    17.             rs = pstm.executeQuery();
    18.             //4.封装结果集
    19.             List<E> list = new ArrayList<E>();//定义返回值
    20.             while(rs.next()) {
    21.                 //实例化要封装的实体类对象
    22.                 E obj = (E)domainClass.newInstance();
    24.                 //取出结果集的元信息：ResultSetMetaData
    25.                 ResultSetMetaData rsmd = rs.getMetaData();
    26.                 //取出总列数
    27.                 int columnCount = rsmd.getColumnCount();
    28.                 //遍历总列数
    29.                 for (int i = 1; i <= columnCount; i++) {
    30.                     //获取每列的名称，列名的序号是从1开始的
    31.                     String columnName = rsmd.getColumnName(i);
    32.                     //根据得到列名，获取每列的值
    33.                     Object columnValue = rs.getObject(columnName);
    34.                     //给obj赋值：使用Java内省机制（借助PropertyDescriptor实现属性的封装）
    35.                     PropertyDescriptor pd = new PropertyDescriptor(columnName,domainClass);//要求：实体类的属性和数据库表的列名保持一种
    36.                     //获取它的写入方法
    37.                     Method writeMethod = pd.getWriteMethod();
    38.                     //把获取的列的值，给对象赋值
    39.                     System.out.println(obj);
    40.                     System.out.println(columnValue);
    41.                     writeMethod.invoke(obj,columnValue);
    42.                 }
    43.                 //把赋好值的对象加入到集合中
    44.                 list.add(obj);
    45.             }
    46.             return list;
    47.         } catch (Exception e) {
    48.             e.printStackTrace();
    49.             throw new RuntimeException(e);
    50.         } finally {
    51.             release(pstm,rs);
    52.         }
    53.     }
    56.     private void release(PreparedStatement pstm,ResultSet rs){
    57.         if(rs != null){
    58.             try {
    59.                 rs.close();
    60.             }catch(Exception e){
    61.                 e.printStackTrace();
    62.             }
    63.         }
    65.         if(pstm != null){
    66.             try {
    67.                 pstm.close();
    68.             }catch(Exception e){
    69.                 e.printStackTrace();
    70.             }
    71.         }
    72.     }
    73. }

    xml解析配置文件

    1. /**
    2.  *  用于解析配置文件
    3.  */
    4. public class XMLConfigBuilder {
    6.     /**
    7.      * 解析主配置文件，把里面的内容填充到DefaultSqlSession所需要的地方
    8.      * 使用的技术：
    9.      *      dom4j+xpath
    10.      */
    11.     public static Configuration loadConfiguration(InputStream config){
    12.         try{
    13.             //定义封装连接信息的配置对象（mybatis的配置对象）
    14.             Configuration cfg = new Configuration();
    16.             //1.获取SAXReader对象
    17.             SAXReader reader = new SAXReader();
    18.             //2.根据字节输入流获取Document对象
    19.             Document document = reader.read(config);
    20.             //3.获取根节点
    21.             Element root = document.getRootElement();
    22.             //4.使用xpath中选择指定节点的方式，获取所有property节点
    23.             List<Element> propertyElements = root.selectNodes("//property");
    24.             //5.遍历节点
    25.             for(Element propertyElement : propertyElements){
    26.                 //判断节点是连接数据库的哪部分信息
    27.                 //取出name属性的值
    28.                 String name = propertyElement.attributeValue("name");
    29.                 if("driver".equals(name)){
    30.                     //表示驱动
    31.                     //获取property标签value属性的值
    32.                     String driver = propertyElement.attributeValue("value");
    33.                     cfg.setDriver(driver);
    34.                 }
    35.                 if("url".equals(name)){
    36.                     //表示连接字符串
    37.                     //获取property标签value属性的值
    38.                     String url = propertyElement.attributeValue("value");
    39.                     cfg.setUrl(url);
    40.                 }
    41.                 if("username".equals(name)){
    42.                     //表示用户名
    43.                     //获取property标签value属性的值
    44.                     String username = propertyElement.attributeValue("value");
    45.                     cfg.setUsername(username);
    46.                 }
    47.                 if("password".equals(name)){
    48.                     //表示密码
    49.                     //获取property标签value属性的值
    50.                     String password = propertyElement.attributeValue("value");
    51.                     cfg.setPassword(password);
    52.                 }
    53.             }
    54.             //取出mappers中的所有mapper标签，判断他们使用了resource还是class属性
    55.             List<Element> mapperElements = root.selectNodes("//mappers/mapper");
    56.             //遍历集合
    57.             for(Element mapperElement : mapperElements){
    58.                 //判断mapperElement使用的是哪个属性
    59.                 Attribute attribute = mapperElement.attribute("resource");
    60.                 if(attribute != null){
    61.                     System.out.println("使用的是XML");
    62.                     //表示有resource属性，用的是XML
    63.                     //取出属性的值
    64.                     String mapperPath = attribute.getValue();//获取属性的值"com/itheima/dao/IUserDao.xml"
    65.                     //把映射配置文件的内容获取出来，封装成一个map
    66.                     Map<String,Mapper> mappers = loadMapperConfiguration(mapperPath);
    67.                     //给configuration中的mappers赋值
    68.                     cfg.setMappers(mappers);
    69.                 }else{
    70.                     System.out.println("使用的是注解");
    71.                     //表示没有resource属性，用的是注解
    72.                     //获取class属性的值
    73.                     String daoClassPath = mapperElement.attributeValue("class");
    74.                     //根据daoClassPath获取封装的必要信息
    75.                     Map<String,Mapper> mappers = loadMapperAnnotation(daoClassPath);
    76.                     //给configuration中的mappers赋值
    77.                     cfg.setMappers(mappers);
    78.                 }
    79.             }
    80.             //返回Configuration
    81.             return cfg;
    82.         }catch(Exception e){
    83.             throw new RuntimeException(e);
    84.         }finally{
    85.             try {
    86.                 config.close();
    87.             }catch(Exception e){
    88.                 e.printStackTrace();
    89.             }
    90.         }
    92.     }
    94.     /**
    95.      * 根据传入的参数，解析XML，并且封装到Map中
    96.      * @param mapperPath    映射配置文件的位置
    97.      * @return  map中包含了获取的唯一标识（key是由dao的全限定类名和方法名组成）
    98.      *          以及执行所需的必要信息（value是一个Mapper对象，里面存放的是执行的SQL语句和要封装的实体类全限定类名）
    99.      */
    100.     private static Map<String,Mapper> loadMapperConfiguration(String mapperPath)throws IOException {
    101.         InputStream in = null;
    102.         try{
    103.             //定义返回值对象
    104.             Map<String,Mapper> mappers = new HashMap<String,Mapper>();
    105.             //1.根据路径获取字节输入流
    106.             in = Resources.getResourceAsStream(mapperPath);
    107.             //2.根据字节输入流获取Document对象
    108.             SAXReader reader = new SAXReader();
    109.             Document document = reader.read(in);
    110.             //3.获取根节点
    111.             Element root = document.getRootElement();
    112.             //4.获取根节点的namespace属性取值
    113.             String namespace = root.attributeValue("namespace");//是组成map中key的部分
    114.             //5.获取所有的select节点
    115.             List<Element> selectElements = root.selectNodes("//select");
    116.             //6.遍历select节点集合
    117.             for(Element selectElement : selectElements){
    118.                 //取出id属性的值      组成map中key的部分
    119.                 String id = selectElement.attributeValue("id");
    120.                 //取出resultType属性的值  组成map中value的部分
    121.                 String resultType = selectElement.attributeValue("resultType");
    122.                 //取出文本内容            组成map中value的部分
    123.                 String queryString = selectElement.getText();
    124.                 //创建Key
    125.                 String key = namespace+"."+id;
    126.                 //创建Value
    127.                 Mapper mapper = new Mapper();
    128.                 mapper.setQueryString(queryString);
    129.                 mapper.setResultType(resultType);
    130.                 //把key和value存入mappers中
    131.                 mappers.put(key,mapper);
    132.             }
    133.             return mappers;
    134.         }catch(Exception e){
    135.             throw new RuntimeException(e);
    136.         }finally{
    137.             in.close();
    138.         }
    139.     }
    141.     /**
    142.      * 根据传入的参数，得到dao中所有被select注解标注的方法。
    143.      * 根据方法名称和类名，以及方法上注解value属性的值，组成Mapper的必要信息
    144.      * @param daoClassPath
    145.      * @return
    146.      */
    147.     private static Map<String,Mapper> loadMapperAnnotation(String daoClassPath)throws Exception{
    148.         //定义返回值对象
    149.         Map<String,Mapper> mappers = new HashMap<String, Mapper>();
    151.         //1.得到dao接口的字节码对象
    152.         Class daoClass = Class.forName(daoClassPath);
    153.         //2.得到dao接口中的方法数组
    154.         Method[] methods = daoClass.getMethods();
    155.         //3.遍历Method数组
    156.         for(Method method : methods){
    157.             //取出每一个方法，判断是否有select注解
    158.             boolean isAnnotated = method.isAnnotationPresent(Select.class);
    159.             if(isAnnotated){
    160.                 //创建Mapper对象
    161.                 Mapper mapper = new Mapper();
    162.                 //取出注解的value属性值
    163.                 Select selectAnno = method.getAnnotation(Select.class);
    164.                 String queryString = selectAnno.value();
    165.                 mapper.setQueryString(queryString);
    166.                 //获取当前方法的返回值，还要求必须带有泛型信息
    167.                 Type type = method.getGenericReturnType();//List<User>
    168.                 //判断type是不是参数化的类型
    169.                 if(type instanceof ParameterizedType){
    170.                     //强转
    171.                     ParameterizedType ptype = (ParameterizedType)type;
    172.                     //得到参数化类型中的实际类型参数
    173.                     Type[] types = ptype.getActualTypeArguments();
    174.                     //取出第一个
    175.                     Class domainClass = (Class)types[0];
    176.                     //获取domainClass的类名
    177.                     String resultType = domainClass.getName();
    178.                     //给Mapper赋值
    179.                     mapper.setResultType(resultType);
    180.                 }
    181.                 //组装key的信息
    182.                 //获取方法的名称
    183.                 String methodName = method.getName();
    184.                 String className = method.getDeclaringClass().getName();
    185.                 String key = className+"."+methodName;
    186.                 //给map赋值
    187.                 mappers.put(key,mapper);
    188.             }
    189.         }
    190.         return mappers;
    191.     }
    193. }