mybatis持久化框架,

2022-07-31 10:45:36 分类：java 阅读()

　　mybatis持久化框架,

　　00-1010自定义框架设计自定义框架实现使用结束框架结束

　　

目录

使用端:

 

　　提供核配置：

　　Sqlmapconfig.xml3360存储数据源信息，引用mapper.xml

　　Mapper.xml : sql语句的配置器信息

　　框架端：

　　1.阅读配置。

　　看完之后以流的形式存在。我们无法将读取的配置信息以流的形式存储在内存中，操作起来比较困难。我们可以创建JavaBean来存储它。

　　(1)配置：存储数据库、仅映射ID、仅映射器ID的基本信息：命名空间“.”身份证。

　　(2)映射语句：sql语句id、SQL语句、输入参数java类型和输出参数java类型

　　2.分析配置部分

　　创建SqlSessionFactoryBuilder类：

　　方法：返回值SqlSessionFactory，方法为build():

　　首先，让dom4j解析配置部分，并将解析的内容封装到Configuration和MappedStatement中。

　　编号：创建SqlSessionFactory的实现类DefaultSqlSessionFactory

　　3.创建SqlSessionFactory:

　　方法：openSession() :获取SqlSession连接的实现类的实例对象。

　　4.创建SqlSession连接和实现类：主要封装crud方法。

　　方法：选择列表(字符串mappedstatementid，对象.param):全部查询

　　select one(string mappedstatementid，object.param):查询单个

　　实现：封装JDBC，完成数据库表的查询操作。

　　涉及到的设计模式:

　　构建器模式、模式、代理模式

　　00-1010这里只做单个查询和多个查询的繁琐实现。添加，修改，删除的引用可以自己实现。

　　

自定义框架设计

创建sqlMapConfig.xml

 

　　配置！-数据库配置信息-data source property name= driver class value= com . MySQL . JDBC . driver /property property name= JDBC URL value= JDBC 3360 MySQL 3360//learning _ db /property property name=用户名 value= root /property property name=密码 value= 123456 /property/data source！-存储mapper.xml的完整路径-mapper resource= user mapper . XML /mapper/configuration http://www . Sina.com/

　　映射器命名空间=com.snf.mapper.UserMapper ！-要组成的- sql: namespace.id的唯一标识符：mappedstatementid-select id= find all result type= com . SNF . domain . user select * from user/select！- User用户=新用户()

　　 user.setId(1); user.setUsername("zhangsan") --> <select id="findByCondition" resultType="com.snf.domain.User" parameterType="com.snf.domain.User"> select * from user where id = #{id} and username = #{username} </select></mapper>User实体类

　　

public class User { private Integer id; private String username; public User() { } public User(Integer id, String username) { this.id = id; this.username = username; } public Integer getId() { return id; } public void setId(Integer id) { this.id = id; } public String getUsername() { return username; } public void setUsername(String username) { this.username = username; } @Override public String toString() { return "User{" + "id=" + id + ", username=" + username +  + }; }}

 

　　

框架端

创建⼀个Maven⼦⼯程并且导⼊需要⽤到的依赖坐标

 

　　

<properties> <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> <maven.compiler.encoding>UTF-8</maven.compiler.encoding> <java.version>1.8</java.version> <maven.compiler.source>1.8</maven.compiler.source> <maven.compiler.target>1.8</maven.compiler.target></properties><dependencies> <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <version>5.1.17</version> </dependency> <dependency> <groupId>c3p0</groupId> <artifactId>c3p0</artifactId> <version>0.9.1.2</version> </dependency> <dependency> <groupId>log4j</groupId> <artifactId>log4j</artifactId> <version>1.2.12</version> </dependency> <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>4.10</version> </dependency> <dependency> <groupId>dom4j</groupId> <artifactId>dom4j</artifactId> <version>1.6.1</version> </dependency> <dependency> <groupId>jaxen</groupId> <artifactId>jaxen</artifactId> <version>1.1.6</version> </dependency></dependencies>

Configuration配置类

 

　　

public class Configuration { private DataSource dataSource; /** * key:statementId value:封装好的mappedStatement对象 */ private Map<String,MappedStatement> mappedStatementMap = new HashMap<>(); public DataSource getDataSource() { return dataSource; } public void setDataSource(DataSource dataSource) { this.dataSource = dataSource; } public Map<String, MappedStatement> getMappedStatementMap() { return mappedStatementMap; } public void setMappedStatementMap(Map<String, MappedStatement> mappedStatementMap) { this.mappedStatementMap = mappedStatementMap; }}

MappedStatement类

 

　　

public class MappedStatement { //sql语句id private String id; //sql语句 private String sql; //输入参数类型 private String parameterType; //返回参数类型 private String resultType; public String getId() { return id; } public void setId(String id) { this.id = id; } public String getSql() { return sql; } public void setSql(String sql) { this.sql = sql; } public String getParameterType() { return parameterType; } public void setParameterType(String parameterType) { this.parameterType = parameterType; } public String getResultType() { return resultType; } public void setResultType(String resultType) { this.resultType = resultType; }}

Resources类

 

　　

public class Resources { //以流的形式读取配置文件 public static InputStream getResourceAsStream(String path){ InputStream resourceAsStream = Resources.class.getClassLoader().getResourceAsStream(path); return resourceAsStream; }}

SqlSessionFactoryBuilder类

 

　　

public class SqlSessionFactoryBuilder { public SqlSessionFactory build(InputStream inputStream) throws PropertyVetoException, DocumentException { //使用dom4j解析配置文件,将解析出来的内容封装到Configuration中 XMLConfigBuilder xmlConfigBuilder = new XMLConfigBuilder(); Configuration configuration = xmlConfigBuilder.parseConfig(inputStream); //创建sqlSessionFactory工厂对象：生产sqlSession DefaultSqlSessionFactory defaultSqlSessionFactory = new DefaultSqlSessionFactory(configuration); return defaultSqlSessionFactory; }}

XMLConfigBuilder类

 

　　

public class XMLConfigBuilder { private Configuration configuration; public XMLConfigBuilder() { this.configuration = new Configuration(); } /** * 使用dom4j对配置文件进行封装,封装Configuration */ public Configuration parseConfig(InputStream inputStream) throws DocumentException, PropertyVetoException { Document document = new SAXReader().read(inputStream); Element rootElement = document.getRootElement(); List<Element> list = rootElement.selectNodes("//property"); Properties properties = new Properties(); list.forEach(element -> { String name = element.attributeValue("name"); String value = element.attributeValue("value"); properties.setProperty(name, value); }); ComboPooledDataSource comboPooledDataSource = new ComboPooledDataSource(); comboPooledDataSource.setDriverClass(properties.getProperty("driverClass")); comboPooledDataSource.setJdbcUrl(properties.getProperty("jdbcUrl")); comboPooledDataSource.setUser(properties.getProperty("username")); comboPooledDataSource.setPassword(properties.getProperty("password")); configuration.setDataSource(comboPooledDataSource); //解析<Mapper>标签 List<Element> mapperList = rootElement.selectNodes("//mapper"); mapperList.stream() .map(x -> x.attributeValue("resource")) .map(Resources::getResourceAsStream) .forEach(resourceAsStream -> { XmlMapperBuilder xmlMapperBuilder = new XmlMapperBuilder(configuration); try { xmlMapperBuilder.parse(resourceAsStream); } catch (DocumentException e) { e.printStackTrace(); } }); return configuration; }}

XMLMapperBuilder类

 

　　

public class XmlMapperBuilder { private Configuration configuration; public XmlMapperBuilder(Configuration configuration) { this.configuration = configuration; } public void parse(InputStream inputStream) throws DocumentException { Document document = new SAXReader().read(inputStream); Element rootElement = document.getRootElement(); String namespace = rootElement.attributeValue("namespace"); List<Element> list = rootElement.selectNodes("//select"); list.forEach(element -> { String id = element.attributeValue("id"); String parameterType = element.attributeValue("parameterType"); String resultType = element.attributeValue("resultType"); String sqlText = element.getTextTrim(); MappedStatement mappedStatement = new MappedStatement(); mappedStatement.setId(id); mappedStatement.setParameterType(parameterType); mappedStatement.setResultType(resultType); mappedStatement.setSql(sqlText); String key = namespace.concat(".").concat(id); configuration.getMappedStatementMap().put(key, mappedStatement); }); }}

SqlSessionFactory接口及DefaultSqlSessionFactory实现类

 

　　

public interface SqlSessionFactory { SqlSession openSession();}
public class DefaultSqlSessionFactory implements SqlSessionFactory { private Configuration configuration; public DefaultSqlSessionFactory(Configuration configuration) { this.configuration = configuration; } @Override public SqlSession openSession() { return new DefaultSqlSession(configuration); }}

SqlSession接口及DefaultSqlSession实现类

 

　　

public interface SqlSession { //查询所有 <E> List<E> selectList(String mappedStatementId,Object... params) throws IllegalAccessException, IntrospectionException, InstantiationException, NoSuchFieldException, SQLException, InvocationTargetException, ClassNotFoundException; //根据条件 <T> T selectOne(String mappedStatementId,Object... params) throws IllegalAccessException, ClassNotFoundException, IntrospectionException, InstantiationException, SQLException, InvocationTargetException, NoSuchFieldException; //为Dao接口生成代理实现类 <T> T getMapper(Class<T> mapperClass);}
public class DefaultSqlSession implements SqlSession { private Configuration configuration; public DefaultSqlSession(Configuration configuration) { this.configuration = configuration; } @Override public <E> List<E> selectList(String mappedStatementId, Object... params) throws IllegalAccessException, IntrospectionException, InstantiationException, NoSuchFieldException, SQLException, InvocationTargetException, ClassNotFoundException { SimpleExecutor simpleExecutor = new SimpleExecutor(); MappedStatement mappedStatement = configuration.getMappedStatementMap().get(mappedStatementId); List<Object> objectList = simpleExecutor.query(configuration, mappedStatement, params); return (List<E>) objectList; } @Override public <T> T selectOne(String mappedStatementId, Object... params) throws IllegalAccessException, ClassNotFoundException, IntrospectionException, InstantiationException, SQLException, InvocationTargetException, NoSuchFieldException { List<Object> objectList = selectList(mappedStatementId, params); if (objectList.size() == 1) { return (T) objectList.get(0); } else { throw new RuntimeException("查询结果为空或者返回结果过多！"); } } @Override public <T> T getMapper(Class<T> mapperClass) { //使用JDK动态代理来为Dao接口生成代理对象,并返回 return (T) Proxy.newProxyInstance(DefaultSqlSession.class.getClassLoader(), new Class[]{mapperClass}, ((proxy, method, args) -> { String methodName = method.getName(); String className = method.getDeclaringClass().getName(); String mappedStatementId = className.concat(".").concat(methodName); //获取被调用方法的返回值类型 Type genericReturnType = method.getGenericReturnType(); //判断是否进行了泛型类型参数化 if (genericReturnType instanceof ParameterizedType){ List<Object> objectList = selectList(mappedStatementId, args); return objectList; } return selectOne(mappedStatementId,args); })); }}

Executor接口及SimpleExecutor实现类

 

　　

public interface Executor { <E>List<E> query(Configuration configuration, MappedStatement mappedStatement,Object... params) throws SQLException, IntrospectionException, InvocationTargetException, IllegalAccessException, InstantiationException, ClassNotFoundException, NoSuchFieldException;}
public class SimpleExecutor implements Executor { @Override public <E> List<E> query(Configuration configuration, MappedStatement mappedStatement, Object... params) throws SQLException, IntrospectionException, InvocationTargetException, IllegalAccessException, InstantiationException, ClassNotFoundException, NoSuchFieldException { //注册驱动,获取连接 Connection connection = configuration.getDataSource().getConnection(); //获取sql语句：select * from user where id = #{id} and username = #{username} //转换sql语句：select * from user where id = ? and username = ? //转换的过程中,还需要对#{}里面的参数名称进行解析存储 String sql = mappedStatement.getSql(); BoundSql boundSql = getBoundSql(sql); //获取预处理对象：preparedStatement PreparedStatement preparedStatement = connection.prepareStatement(boundSql.getSqlText()); //设置参数 //获取到了参数的全路径 String parameterType = mappedStatement.getParameterType(); Class<?> parameterTypeClass = getClassType(parameterType); List<ParameterMapping> parameterMappingList = boundSql.getParameterMappingList(); for (int i = 0; i < parameterMappingList.size(); i++) { ParameterMapping parameterMapping = parameterMappingList.get(i); String content = parameterMapping.getContent(); //反射 Field declaredField = parameterTypeClass.getDeclaredField(content); //暴力访问 declaredField.setAccessible(true); Object o = declaredField.get(params[0]); preparedStatement.setObject(i + 1, o); } //执行sql ResultSet resultSet = preparedStatement.executeQuery(); String resultType = mappedStatement.getResultType(); Class<?> resultTypeClass = getClassType(resultType); List<Object> objectList = new ArrayList<>(); //封装返回结果集 while (resultSet.next()) { Object o = resultTypeClass.newInstance(); //元数据 ResultSetMetaData metaData = resultSet.getMetaData(); for (int i = 1; i <= metaData.getColumnCount(); i++) { // 字段名 String columnName = metaData.getColumnName(i); // 字段的值 Object value = resultSet.getObject(columnName); //使用反射或者内省,根据数据库表和实体的对应关系,完成封装 PropertyDescriptor propertyDescriptor = new PropertyDescriptor(columnName, resultTypeClass); Method writeMethod = propertyDescriptor.getWriteMethod(); writeMethod.invoke(o, value); } objectList.add(o); } return (List<E>) objectList; } private Class<?> getClassType(String paramterType) throws ClassNotFoundException { if (paramterType != null) { Class<?> aClass = Class.forName(paramterType); return aClass; } return null; } /** * 完成对#{}的解析工作 * 1.将#{}使用?进行代替 * 2.解析出#{}里面的字段名进行存储 * * @param sql * @return */ private BoundSql getBoundSql(String sql) { //标记处理类：配置标记解析器来完成对占位符的解析处理工作 ParameterMappingTokenHandler parameterMappingTokenHandler = new ParameterMappingTokenHandler(); GenericTokenParser genericTokenParser = new GenericTokenParser("#{", "}", parameterMappingTokenHandler); //解析出来的sql String parseSql = genericTokenParser.parse(sql); //#{}里面解析出来的参数名称 List<ParameterMapping> parameterMappings = parameterMappingTokenHandler.getParameterMappings(); BoundSql boundSql = new BoundSql(parseSql, parameterMappings); return boundSql; }}

BoundSql类

 

　　

public class BoundSql { private String sqlText; //解析过后的sql private List<ParameterMapping> parameterMappingList = new ArrayList<>(); public BoundSql(String sqlText, List<ParameterMapping> parameterMappingList) { this.sqlText = sqlText; this.parameterMappingList = parameterMappingList; } public String getSqlText() { return sqlText; } public void setSqlText(String sqlText) { this.sqlText = sqlText; } public List<ParameterMapping> getParameterMappingList() { return parameterMappingList; } public void setParameterMappingList(List<ParameterMapping> parameterMappingList) { this.parameterMappingList = parameterMappingList; }}

GenericTokenParser、ParameterMapping、TokenHandler、ParameterMappingTokenHandler工具类

 

　　GenericTokenParser：解析${}或#{}中的参数名称

　　ParameterMapping：存储${}或#{}中的参数名称

　　TokenHandler：替换${}或#{}处理接口

　　ParameterMappingTokenHandler：替换${}或#{}处理接口的实现类

　　

public class GenericTokenParser { private final String openToken; //开始标记 private final String closeToken; //结束标记 private final TokenHandler handler; //标记处理器 public GenericTokenParser(String openToken, String closeToken, TokenHandler handler) { this.openToken = openToken; this.closeToken = closeToken; this.handler = handler; } /** * 解析${}和#{} * @param text * @return * 该方法主要实现了配置文件、脚本等片段中占位符的解析、处理工作，并返回最终需要的数据。 * 其中，解析工作由该方法完成，处理工作是由处理器handler的handleToken()方法来实现 */ public String parse(String text) { // 验证参数问题，如果是null，就返回空字符串。 if (text == null text.isEmpty()) { return ""; } // 下面继续验证是否包含开始标签，如果不包含，默认不是占位符，直接原样返回即可，否则继续执行。 int start = text.indexOf(openToken, 0); if (start == -1) { return text; } // 把text转成字符数组src，并且定义默认偏移量offset=0、存储最终需要返回字符串的变量builder， // text变量中占位符对应的变量名expression。判断start是否大于-1(即text中是否存在openToken)，如果存在就执行下面代码 char[] src = text.toCharArray(); int offset = 0; final StringBuilder builder = new StringBuilder(); StringBuilder expression = null; while (start > -1) { // 判断如果开始标记前如果有转义字符，就不作为openToken进行处理，否则继续处理 if (start > 0 && src[start - 1] == \) { builder.append(src, offset, start - offset - 1).append(openToken); offset = start + openToken.length(); } else { //重置expression变量，避免空指针或者老数据干扰。 if (expression == null) { expression = new StringBuilder(); } else { expression.setLength(0); } builder.append(src, offset, start - offset); offset = start + openToken.length(); int end = text.indexOf(closeToken, offset); while (end > -1) {////存在结束标记时 if (end > offset && src[end - 1] == \) {//如果结束标记前面有转义字符时 // this close token is escaped. remove the backslash and continue. expression.append(src, offset, end - offset - 1).append(closeToken); offset = end + closeToken.length(); end = text.indexOf(closeToken, offset); } else {//不存在转义字符，即需要作为参数进行处理 expression.append(src, offset, end - offset); offset = end + closeToken.length(); break; } } if (end == -1) { // close token&      

	  
	  
	  
	  
	  
	  
        
郑重声明：本文由网友发布，不代表盛行IT的观点，版权归原作者所有，仅为传播更多信息之目的，如有侵权请联系，我们将第一时间修改或删除，多谢。
标签：

相关文章阅读

  • ,,详解Mybatis通用Mapper介绍与使用
  • ,,Mybatis中强大的resultMap功能介绍
  • ,,MyBatis中传入参数parameterType类型详解
  • ,,MybatisPlus中的删除和逻辑删除及区别介绍
  • ,,MyBatis-Plus 通用IService使用详解
  • ,,Mybatis-Plus 搭建与使用入门(小结)
  • mybatis 批量insert 返回id,mybatis返回新增数据的id
  • basemapper是什么,mybatis basemapper实现
  • mybatis底层工作原理,mybatis 底层
  • mybatis延迟加载使用场景,mybatis延迟加载配置
  • ,mybatisplus mybatis区别
  • mybatis搭建,mybatis部署
  • mybatisplus单表查询,mybatislist查询
  • mybatis代理模式,mybatis代理对象
  • mybatis动态sql原理,mybatis动态sql判断字段为空
    • 留言与评论（共有 条评论）
       
    验证码：