9_Jvn框架之实现ORM持久层save操作(第九讲)

本次博客讲的内容:

场景:以前使用JDBC的时候对于jbdc相信很多人都做了不同的封装,因为纯JDBC的操作还是相对来说比较繁琐的。所以今天我们也来封装一下JBDC

把它集成到我们的Jvn框架里面。

解决思路:

  不清楚可以直接看下面的代码。

1,操作数据库前引入连接池概念 druid。连接池的好处,相信大家都懂啦。

  2,引入ThreadLocal。泛型指定Connection,用来存放链接。该类可以保证你在一个线程里面获取得到的是同一个Connection。

  3,创建JDBC类 存放 driver  user pasword jdbcUrl.

  4,  创建pool接口,定义 getConnection方法,面向接口思想,以后可能有c3p0,druid等等连接池。

  5,定义接口实现类DruidPool,定义属性 ThreadLocal<Connection> connections,初始化创建于数据库链接,提供getConnection()方法,获取时,先判断

  connections.get()是否空,如果为空,从Druid连接池获取,然后在connections.set(conn);

  6,创建DB类,里面封装对JDBC操作的封装. 

  7,将实体类跟DAO合并,定义父类JvnModel ,里面有两属性,String = tableName(对应表名),Map = attrs(数据库字段),定义save(),update(),delete(),find()

  等方法,本次实现save()方法(这里调用的是DB.save),即保存一条数据方法,其他的下集讲解。

  8,对于save()操作的分析,Mysql增加一条数据操作为 insert into user (name,age,school) values(?,?,?)这种结构 分析为如下三步,

    insert into user (key) values(wenhao)根据要插入的参数有多少个生成多少个key参数多少个问号:

    第一步 key=name,age, school  去除掉最后一个“逗号”。

    第二步 wenhao = ?,?, ?,    去除最后一个逗号

    然后拼接起来  insert into user (name,age,school) values(?,?,?)  在执行插入对应参数值。

    得到insert into user (name,age,school) values(everxs,100,清华)

  9,定义@Model注解类,给对应的model注解。

  10,启动扫描有@Model注解的类添加进Map里面

代码示例:

jdbc:

public class Jdbc {

	private String driver;
	private String user;
	private String password;
	private String jdbcUrl;

	public Jdbc() {

	}

	public Jdbc(String driver, String user, String password, String jdbcUrl) {
		super();
		this.driver = driver;
		this.user = user;
		this.password = password;
		this.jdbcUrl = jdbcUrl;
	}

	public String getDriver() {
		return driver;
	}
	public void setDriver(String driver) {
		this.driver = driver;
	}
	public String getUser() {
		return user;
	}
	public void setUser(String user) {
		this.user = user;
	}
	public String getPassword() {
		return password;
	}
	public void setPassword(String password) {
		this.password = password;
	}
	public String getJdbcUrl() {
		return jdbcUrl;
	}
	public void setJdbcUrl(String jdbcUrl) {
		this.jdbcUrl = jdbcUrl;
	}

}

pool接口:

public interface Pool {

	public  Connection getConnection();
}

DruidPool实现类:

/**
 * druid连接池
 * @author everxs
 *
 */
public class DruidPool implements Pool{

	private static  DruidDataSource dataSource;
	private ThreadLocal<Connection> connections = new ThreadLocal<Connection>();
	/**
	 * 创建好druid
	 * @param jdbc
	 */
	public DruidPool(Jdbc jdbc) {
		dataSource = new DruidDataSource();
		dataSource.setDriverClassName(jdbc.getDriver());
		dataSource.setUsername(jdbc.getUser());
		dataSource.setPassword(jdbc.getPassword());
		dataSource.setUrl(jdbc.getJdbcUrl());
		dataSource.setPoolPreparedStatements(true);
		dataSource.setMaxPoolPreparedStatementPerConnectionSize(20);
		dataSource.setInitialSize(5);
		dataSource.setMinIdle(1);
		dataSource.setMaxActive(10);
		dataSource.setMaxWait(60000);
		// 启用监控统计功能
		 try {
			dataSource.setFilters("stat");
		} catch (SQLException e) {

			e.printStackTrace();
		}// for mysql
		 dataSource.setPoolPreparedStatements(false);
	}
	public DruidPool() {
	}
	/**
	 * 获取一个连接
	 * @return
	 */
	public synchronized  Connection getConnection() {
		Connection conn = connections.get();
		System.out.println("进入 :"+conn);

		try {
			if(conn==null||conn.isClosed()){

				conn = dataSource.getConnection();
				System.out.println("null 后:"+conn);
				connections.set(conn);
			}

		} catch (Exception e) {

			throw new RuntimeException(e);
		}
		return conn;
	}
}

JvnModel类:

public class JvnModel<T extends JvnModel> {

	private Map<String,Object> attrs = new HashMap<String, Object>();
	private  String tableName = JvnConfig.CONSTANT.getTable().getTable(this.getClass());

	/**
	 * 保存操作
	 * @return
	 */
	public  int save(){
		int i = save(JvnConfig.pool.getConnection());
		return i;
	}

	/**
	 * 保存操作
	 * @return
	 */
	public int save(Connection conn){

		int i = Db.save(tableName, this);
		return i;
	}

	public Map<String, Object> getAttrs() {
		return attrs;
	}

	public void setAttrs(Map<String, Object> attrs) {
		this.attrs = attrs;
	}

	public String getTableName() {
		return tableName;
	}

	public void setTableName(String tableName) {
		this.tableName = tableName;
	}

	public void set(String attr,Object value){
		attrs.put(attr, value);
	}

	public Object get(String attr){
		return attrs.get(attr);
	}
}

DB类:

/**
 * 数据库查询通用类
 * @author everxs
 *
 */
public class Db {

	/**
	 * 保存操作
	 * @return
	 */
	public static int save(String tableName,JvnModel model){
		return save( tableName, model,JvnConfig.pool.getConnection());
	}

	/**
	 * 保存操作
	 * @return
	 */
	public static int save(String tableName,JvnModel model,Connection conn){
		int result= -1;

		PreparedStatement ps= null;
		ResultSet rs =null;
		try{
			String keys="";
			String wenhao = "";
			Object values[]=new String[model.getAttrs().size()];
			int i = 0;
			Map<String,String>strMap = MapKit.toStringMap(model.getAttrs());
			for(String attr : strMap.keySet()){
				keys = keys+attr+",";
				wenhao = wenhao+"?,";
				values[i] =  strMap.get(attr);
				i++;

			}
			if(keys.endsWith(",")){
				keys = keys.substring(0,keys.length()-1);
			}
			if(wenhao.endsWith(",")){
				wenhao = wenhao.substring(0,wenhao.length()-1);
			}

			String sql = "insert into "+tableName+"("+keys+")values("+wenhao+")";
			ps = conn.prepareStatement(sql,Statement.RETURN_GENERATED_KEYS);

			for (i = 0; i < values.length; i++) {
				ps.setObject(i + 1, values[i]);
			}

			// 执行操作
			result = ps.executeUpdate();
			rs = ps.getGeneratedKeys();
		     if (rs.next()) {
                 //知其仅有一列,故获取第一列
                 Long id = rs.getLong(1);
                 model.set("id", id);
		     }

		}catch(Exception e){
			throw new RuntimeException(e);
		}finally{
			if(rs!=null){
				try {
					rs.close();
				} catch (SQLException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
			if(ps!=null){
				try {
					ps.close();
				} catch (SQLException e) {
					e.printStackTrace();
				}
			}
			try {
				if(conn!=null&&conn.getAutoCommit()){
					conn.close();
				}
			} catch (Exception e) {
				e.printStackTrace();
			}

		}
		return result;
	}

}

Model注解:

/**
 * 注解实体类
 * @author everxs
 *
 */
@Retention(RetentionPolicy.RUNTIME)
public @interface Model {

	String name();

}

扫描类代码:

	public static void scanClass(Constant constant){
		//拿到classes绝对路劲
		String path = ScanKit.class.getClassLoader().getResource("").getPath();
		//得到类的全名称  例如: con.everxs.test.TestController.class
		List<String> listClass= FileKit.listClassFileAbsolutePath(path);
		for(String clazzStr : listClass){
			try {
				//找到这个类全名称的Class
				Class clazz = Class.forName(clazzStr);

				if(clazz!=null){
					Controller controller= (Controller) clazz.getAnnotation(Controller.class);
					Model model = (Model) clazz.getAnnotation(Model.class);
					if(controller!=null){
						constant.setRoute(controller.space(), clazz);
					}
					if(model!=null){
						constant.getTable().setTable(clazz, model.name());
					}

				}
			} catch (Exception e) {
				System.out.println("找不到类文件");
			}
		}
	}

测试 Member类:

@Model(name = "member")
public class Member extends JvnModel<Member>{

}

测试Controller:

@Controller(space = "/member")
public class MemberController extends JvnController{

	public void save(){

		Member member = new Member();
		member.set("name", "everxs");
		member.set("age", 18);
		member.save();

		renderString("增加成功!");
	}
}

结果:保存数据库成功。

关于Jvn:

    框架命名为Jvn,博客里有连续的开发视频,每一篇博文都是一个知识点,关于框架的介绍和学习,可以从我博客第一讲开始看起;

    本次内容的源码与视频下载地址:http://pan.baidu.com/s/1i3iY9fv

    Jvn框架QQ交流群:399603805

    博客首页:http://www.cnblogs.com/everxs/

    永远的八哥...

    

时间: 2024-09-28 15:40:40

9_Jvn框架之实现ORM持久层save操作(第九讲)的相关文章

手写ORM持久层框架

根据尚学堂录的教程做的.: 配置文件 db.properties driver=com.mysql.jdbc.Driver url=jdbc\:mysql\://127.0.0.1\:3306/sorm user=root password=123 usingDB=mysql srcPath=/home/frank/MyEclipseWorkSpace/S_ORM/src poPackage=com.frank.po queryClass=com.frank.sorm.core.imp.MySq

c++ 数据持久层研究(一)

C++ORM框架自动生成代码数据库 用过Java的都知道SSH框架,特别对于数据库开发,Java领域有无数的ORM框架,供数据持久层调用,如Hibernate,iBatis(现在改名叫MyBatis),TopLink,JDO,JPA……非常方便实用. 用过C#的同学们也都知道通过CodeSmith软件,生成微软的PetShop分层模式,达到数据持久层的代码,也非常方便. 那么我们用C++的怎么办,我们也是面向对象编程,在工作中也有数据库需要管理.我们需要完全手工去写那些重复性的代码吗? 特别我现

数据持久层

1.数据持久化 数据持久化就是将内存中的数据模型转换为存储模型,以及将存储模型转换为内存中的数据模型的统称. 数据模型可以是任何数据结构或对象模型, 存储模型可以是关系模型.XML.二进制流等. cmp和Hibernate只是对象模型到关系模型之间转换的不同实现. 数据持久化的好处: 1.程序代码重用性强,即使更换数据库,只需要更改配置文件,不必重写程序代码. 2.业务逻辑代码可读性强,在代码中不会有大量的SQL语言,提高程序的可读性. 3.持久化技术可以自动优化,以减少对数据库的访问量,提高程

mybatis与hibernate的区别持久层对比【面试题】

Mybatis技术特点: 好处: 通过直接编写SQL语句,可以直接对SQL进行性能的优化: 学习门槛低,学习成本低.只要有SQL基础,就可以学习mybatis,而且很容易上手: 由于直接编写SQL语句,所以灵活多变,代码维护性更好. 缺点: 不能支持数据库无关性,即数据库发生变更,要写多套代码进行支持,移植性不好. Mysql:limit Oracle:rownum 需要编写结果映射. Hibernate技术特点: 好处: 标准的orm框架,程序员不需要编写SQL语句. 具有良好的数据库无关性,

JAVAWEB开发之Hibernate详解(一)——Hibernate的框架概述、开发流程、CURD操作和核心配置与API以及Hibernate日志的使用

Hibernate框架概述 什么是Hibernate? 框架:软件的半成品,完成部分代码的功能. Hibernate:Hibernate是一个开放源代码的对象关系映射框架,它对JDBC进行了非常轻量级的对象封装,使得Java程序员可以随心所欲的使用对象编程思想来操作数据库.Hibernate可以应用在任何使用JDBC的场合,既可以在Java的客户端程序中使用,也可以在Servlet/JSP的web应用程序中使用,最具革命意义的是,Hibernate可以在应用EJB的J2EE架构中取代CMP,完成

Rexdb:高性能的数据持久层(ORM)框架

Rexdb是一款使用Java语言编写的,开放源代码的数据持久层框架(腾云科技ty300.com).提供了查询.更新.批处理.调用.(JTA)事务.数据源管理等功能,可以取代Mybatis.Hibernate作为系统的核心ORM框架(基础教程qkxue.net). Rexdb提供了工具类风格的接口,不需要编写映射配置,使用简便:同时,它还具备同类框架中最高效的执行效率. Rexdb的某次性能测试结果为:查询性能是Hibernate的2.3倍,Mybatis的1.7倍.

SpringBoot2.0 基础案例(09):集成JPA持久层框架,简化数据库操作

一.JAP框架简介 JPA(Java Persistence API)意即Java持久化API,是Sun官方在JDK5.0后提出的Java持久化规范.主要是为了简化持久层开发以及整合ORM技术,结束Hibernate.TopLink.JDO等ORM框架各自为营的局面.JPA是在吸收现有ORM框架的基础上发展而来,易于使用,伸缩性强. 二.与SpringBoot2.0整合 1.核心依赖 <!-- JPA框架 --> <dependency> <groupId>org.sp

持久层框架hibernate相关概念

hibernate为全自动的持久层框架(framework): 1.作用:把内存中的活跃对象永远的保存在关系型数据库中. 2.O/R/M原理:O-->object 对象,R---> relational关系型数据库,M--->mapping映射 为了解决应用程序中的对象和关系型数据库中的表的不匹配而提出的一个解决方案. 3.新版本hibernate4中怎么得到session工厂从而创建连接对象 Configuration cfg = new Configuration().configu

Java数据持久层框架 MyBatis

MyBatis 详细介绍 MyBatis 的前身就是 iBatis .是一个数据持久层(ORM)框架. iBATIS一词来源于"internet"和"abatis"的组合,是一个基于Java的持久层框架.iBATIS提供的持久层框架包括SQL Maps和Data Access Objects(DAO),同时还提供一个利用这个框架开发的 JPetStore实例. 源码来源:minglisoft.cn/technology