DAO 模式
 
DAO (Data Access Object 数据存取对象)是指位于业务逻辑和持久化数据之间实现对持久化数据的访问。通俗来讲，就是将数据库操作都封装起来。（接口设计+SQL编写，不涉及业务代码）
 
DAO 包含的模块：
 
dao :接口层(Mapper 自动实现DAO接口，API编程方式实现DAO接口)，一般采用Mapper 自动实现DAO接口
entity：实体层
resource：sql(xml提供sql，注解提供sql),一般使用前者，注解对于简单sql使用较为方便
mybatis 实现原理 参数+sql =Entity/List
 
 
 
mybatis 参数配置注意点：
 
<!-- 使用jdbc的getGeneratedKeys 获取数据库自增主键值 -->
<setting name="useGeneratedKeys" value="true"/>
<!-- 使用列别名替换列名，默认: true 
    select content as title from table 
-->
<setting name="useColumnLabel" value="true"/>
<!-- 开启驼峰命名转换 : Table(create_time) -> Entity(createTime) -->
<setting name="mapUnderscoreToCamelCase" value="true"/>
 
mybatis奇技淫巧：
 
ignore 使用 ，为防止主键冲突，使用ignore关键字，若插入失败不会抛异常，而是返回插入成功的条数为0。 
    <insert id="insertSuccessKilled">
        <!--当出现主键冲突时(即重复秒杀时)，会报错;不想让程序报错，加入ignore-->
        INSERT ignore INTO success_killed(seckill_id,user_phone,state)
        VALUES (#{seckillId},#{userPhone},0)
    </insert>
 
 
 
返回结果实体中出现多对1的情况，用双引号指明是对象的那个属性 
<select id="queryByIdWithSeckill" resultType="SuccessKilled">

        <!--根据seckillId查询SuccessKilled对象，并携带Seckill对象-->
        <!--如何告诉mybatis把结果映射到SuccessKill属性同时映射到Seckill属性-->
        <!--可以自由控制SQL语句-->

        SELECT
            sk.seckill_id,
            sk.user_phone,
            sk.create_time,
            sk.state,
            s.seckill_id "seckill.seckill_id",
            s.name "seckill.name",
            s.number "seckill.number",
            s.start_time "seckill.start_time",
            s.end_time "seckill.end_time",
            s.create_time "seckill.create_time"
        FROM success_killed sk
        INNER JOIN seckill s ON sk.seckill_id=s.seckill_id
        WHERE sk.seckill_id=#{seckillId} and sk.user_phone=#{userPhone}
    </select>
 
 
 
多参数需要用@param注解，java没有形参保存记录
 
 
mybatis 与Spring整合
 
配置数据库连接池 
<!--配置整合mybatis过程
    1.配置数据库相关参数-->
    <context:property-placeholder location="classpath:jdbc.properties"/>

    <!--2.数据库连接池-->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <!--配置连接池属性-->
        <property name="driverClass" value="${jdbc.driver}" />

        <!-- 基本属性 url、user、password -->
        <property name="jdbcUrl" value="${jdbc.url}" />
        <property name="user" value="${jdbc.username}" />
        <property name="password" value="${jdbc.password}" />

        <!--c3p0私有属性-->
        <property name="maxPoolSize" value="30"/>
        <property name="minPoolSize" value="10"/>
        <!--关闭连接后不自动commit-->
        <property name="autoCommitOnClose" value="false"/>

        <!--获取连接超时时间-->
        <property name="checkoutTimeout" value="1000"/>
        <!--当获取连接失败重试次数-->
        <property name="acquireRetryAttempts" value="2"/>
    </bean>
 
 
 
配置SqlSessionFactory对象，约定大于配置 
<!--约定大于配置-->
    <!--３.配置SqlSessionFactory对象-->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <!--往下才是mybatis和spring真正整合的配置-->
        <!--注入数据库连接池-->
        <property name="dataSource" ref="dataSource"/>
        <!--配置mybatis全局配置文件:mybatis-config.xml-->
        <property name="configLocation" value="classpath:mybatis-config.xml"/>
        <!--扫描entity包,使用别名,多个用;隔开-->
        <property name="typeAliasesPackage" value="cn.codingxiaxw.entity"/>
        <!--扫描sql配置文件:mapper需要的xml文件-->
        <property name="mapperLocations" value="classpath:mapper/*.xml"/>
    </bean>
 
 
 
配置扫描DAO接口包，动态实现DAO接口，注入到spring容器中 
    <!--４:配置扫描Dao接口包,动态实现DAO接口,注入到spring容器-->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <!--注入SqlSessionFactory-->
        <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/>
        <!-- 给出需要扫描的Dao接口-->
        <property name="basePackage" value="cn.codingxiaxw.dao"/>
    </bean>
 
 
 
最后，需要到dao层接口单独写单元测试

DAO模式入门
 
1.什么是DAO模式
 
DAO模式是标准的J2EE设计模式之一.开发人员使用这个模式把底层的数据访问操作和上层的业务逻辑分开，此模式的主要作用是封装对数据库的各种操作；
 
2.DAO模式的组成部分
 
 
VO：值对象，此对象只包含属性，而没有方法；代表数据库中表中的一条记录，一个VO与一个表是相对应的
DAO接口：定义对某个VO的所有操作
DAO实现类：DAO接口的具体实现
DAO工厂类：用来创建出DAO对象（可以没有）
 
 
3.案例代码
 
  项目结构
 

 
 
 
说明
 
 
Book:图书表的VO类
BaseDao:所有DAO的父类，封装了所有DAO中可以使用的的通用方法
BookDao:图书的数据访问接口，定义了对图书表操作的所有方法
BookDaoImp:BookDao的实现类；
DaoTest:测试方法
 
 
4.部分代码
 
book.java
 
 
package com.oracle.vo;

public class Book {
	private Integer isbn; //图书编号
	private String bookName;//书名
	private Integer price;//价格
	
	
	@Override
	public String toString() {
		return "Book [isbn=" + isbn + ", bookName=" + bookName + ", price=" + price + "]";
	}
	public Integer getIsbn() {
		return isbn;
	}
	public void setIsbn(Integer isbn) {
		this.isbn = isbn;
	}
	public String getBookName() {
		return bookName;
	}
	public void setBookName(String bookName) {
		this.bookName = bookName;
	}
	public Integer getPrice() {
		return price;
	}
	public void setPrice(Integer price) {
		this.price = price;
	}
	public Book(String bookName, Integer price) {
		super();
		this.bookName = bookName;
		this.price = price;
	}
	public Book() {
		super();
	}	
}


 BaseDao.java 
 
 
/**
 * 所有Dao的父类
 */
package com.oracle.dao;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.util.*;

public class BaseDao {
	
	//获得连接
	public Connection getConnection() {
		Connection conn=null;
		try {
			conn=DriverManager.getConnection("jdbc:mysql://localhost:3306/books","root","tiger");
		} catch (SQLException e) {
			e.printStackTrace();
		}
		return conn;
	}
	
	/**
	 * 关闭资源
	 * @param auto,jdk7后的接口
	 */
	public void close(AutoCloseable auto) {
		if(auto!=null) {
			try {
				auto.close();
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
	}
	
	/**
	 * 动态执行sql
	 * @param sql:预编译的sql
	 * @param objs:可变参数
	 */
	public void executeSql(String sql,Object...objs) {
		//获得连接
		Connection conn=this.getConnection();
		PreparedStatement ps=null;
		try {
			ps=conn.prepareStatement(sql);
			//设置参数
			for(int i=0;i<objs.length;i++) {
				ps.setObject(i+1, objs[i]);
			}
			//执行sql
			ps.execute();
		}catch(Exception e) {
			e.printStackTrace();
		}finally {
			this.close(ps);
			this.close(conn);
		}
	}
	
	/**
	 * 执行一条select语名，并且将返回结果封装到List中，每条记录对一个Map
	 * @param sql:sql查询语句，可带参数(?)
	 * @param objs:可变参数
	 * @return
	 */
	public List<Map<String,Object>> executeQuery(String sql,Object...objs){
		List<Map<String,Object>> list=new ArrayList<Map<String,Object>>();
		Connection conn=this.getConnection();
		PreparedStatement ps=null;
		ResultSet rs=null;
		try {
			ps=conn.prepareStatement(sql);
			for(int i=0;i<objs.length;i++) {
				ps.setObject(i+1, objs[i]);
			}
			//执行查询
			rs=ps.executeQuery();
			//获得元数据
			ResultSetMetaData rsmd=rs.getMetaData();
			//将每条记录转成一个Map,key是列名，value是字段值
			while(rs.next()) {
				Map<String,Object> map=new HashMap<String,Object>();
				for(int i=1;i<=rsmd.getColumnCount();i++) {
					map.put(rsmd.getColumnLabel(i), rs.getObject(i));
				}
				list.add(map);
			}
			
		}catch(Exception e) {
			e.printStackTrace();
		}finally {
			this.close(rs);
			this.close(ps);
			this.close(conn);
		}		
		return list;
	}
}


 BookDao.java 
 
 
package com.oracle.dao;

import java.util.List;

import com.oracle.vo.Book;

public interface BookDao {
	//插入图书
	public void save(Book book); 
	//修改图书
	public void update(Book book);
	//删除图书
	public void delete(int isbn);
	//查询所有图书
	public List<Book> getAll();
	//根据图书编号获得图书 
	public Book getBookById(int isbn);
	//分页查询图书
	public List<Book> getAllByPage(int pageNumber,int pageSize);
}


 BookDaoImpl.java 
 
 
package com.oracle.dao;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;

import com.oracle.vo.Book;

public class BookDaoImpl extends BaseDao implements BookDao {

	@Override
	/**
	 * 插入图书
	 */
	public void save(Book book) {
		this.executeSql("insert into book values(null,?,?)", book.getBookName(),book.getPrice());
	}

	@Override
	/**
	 * 修改图书 
	 */
	public void update(Book book) {
		this.executeSql("update book set bookName=?,price=? where isbn=?", book.getBookName(),book.getPrice(),book.getIsbn());
	}

	@Override
	/**
	 * 删除图书
	 */
	public void delete(int isbn) {
		this.executeSql("delete from book where isbn=?", isbn);
	}

	@Override
	/**
	 * 获得所有的图书
	 */
	public List<Book> getAll() {	
		return this.convert(this.executeQuery("select isbn,bookName,price from book"));
	}

	@Override
	/**
	 * 根据主键获得唯一的图书
	 */
	public Book getBookById(int isbn) {
		List<Book> list=this.convert(this.executeQuery("select isbn,bookName,price from book where isbn=?",isbn));
		return list.isEmpty()?null:list.get(0);
	}

	@Override
	/**
	 * 分页查询
	 */
	public List<Book> getAllByPage(int pageNumber, int pageSize) {
		return this.convert(this.executeQuery("select isbn,bookName,price from book order by isbn limit ?,?",(pageNumber-1)*pageSize,pageSize));
	}

	/**
	 * 将Map转成Book
	 * @param list
	 * @return
	 */
	private List<Book> convert(List<Map<String,Object>> list){
		List<Book> bList=new ArrayList<Book>();
		for(Map<String,Object> map:list) {
			Book b=new Book();
			b.setIsbn((Integer)map.get("isbn"));
			b.setBookName(map.get("bookName").toString());
			b.setPrice((Integer)map.get("price"));
			bList.add(b);
		}
		return bList;
	}
}


 DaoTest.java 
 
 
package com.oracle.test;

import java.util.List;

import com.oracle.dao.BookDao;
import com.oracle.dao.BookDaoImpl;
import com.oracle.vo.Book;

public class DaoTest {

	public static void main(String[] args) {

		BookDao dao = new BookDaoImpl();

		// 插入图书测试
		Book book = new Book("把球交给薛庭政", 3);
		dao.save(book);
		
		//修改图书
		book.setIsbn(5600);
		book.setBookName("大话数据结构");
		dao.update(book);
		
		// 删除图书
		dao.delete(569);

		// 查询所有图书
		List<Book> list = dao.getAll();
		for (Book b : list) {
			System.out.println(b);
		}

		System.out.println("---------");
		// 查询一本图书
		System.out.println(dao.getBookById(666));

		//分页查询
		list = dao.getAllByPage(2, 5);
		for (Book b : list) {
			System.out.println(b);
		}
	}

}


 
源码下载

 

1、https://blog.csdn.net/uestc_lxp/article/details/45363805

第一步：检查MySQL是否准备妥当
首先检查mysql是否安装成功
通过cmd进去mysql：以管理员身份运行cmd->输入：mysql -h localhost -u root -p -->输入密码-->成功进入。这一步操作是为了检查mysql是否安装成功。

查看MySQL中有哪些数据库以及表
mysql 显示所有的数据库：https://blog.csdn.net/u010746364/article/details/53078550
下载mysql视图管理工具Navicat,查看数据库结构

 




第二步：新建一个Java项目并配置好数据库的驱动程序
java连接mysql数据库的详细步骤：https://blog.csdn.net/huwentao0305/article/details/53378755


新建数据库连接类


由于所有数据库的连接操作都是固定的步骤，所以单独定义一个DatabaseConnection类，这个类主要负责
1.取得数据库的连接对象；
public Connection getConnection() {
		return this.conn; //返回本类对象中的Connection对象
	}
2.数据库的关闭操作；
	public void close() {
		if(this.conn != null) { //表示现在有连接对象
			try {
				this.conn.close();
			} catch (SQLException e) {
				e.printStackTrace();
			}
		}
	}
3.DatabaseConnection()的构造方法：在其中实现数据库的连接！//在实例化本类对象时就意味着要进行数据库的开发
public DatabaseConnection() {
		try {
			Class.forName(DBDRIVER); //加载驱动程序
			this.conn = DriverManager.getConnection(DBURL, DBUSER, PASSWORD); //连接数据库
		} catch (Exception e) {
			e.printStackTrace();
		} 
	}
4.储存以下数据：驱动程序名、数据库路径、数据库用户名、数据库密码，同时需要新建一个Connection对象。
private static final String DBDRIVER = "com.jdbc.mysql.Driver" ; //驱动程序名
private static final String DBURL = "jdbc:mysql://localhost:3306/test" ; //数据库路径
private static final String DBUSER = "root" ; //用户名
private static final String PASSWORD = "*******" ; //密码
private Connection conn ; //Connection对象
既然是一个专门用于数据库的连接操作，则将其保存在dbc子包中。


该类完整代码如下：
package com.fs.dbc;

import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Connection;

/**
 * 本类专门负责数据库的连接和关闭，在实例化本类对象时就意味着要进行数据库的开发
 * 所以在本类的构造方法里要进行数据库驱动加载和数据库连接取得
 * @author 婉阿婉
 * 所以需要提供getConnection()、close()方法。
 */
public class DatabaseConnection {
	private static final String DBDRIVER = "com.jdbc.mysql.Driver" ; //驱动程序名
	private static final String DBURL = "jdbc:mysql://localhost:3306/test" ; //数据库的路径
	private static final String DBUSER = "root" ; //用户名
	private static final String PASSWORD = "*******" ; //密码
	private Connection conn ; //声明Connection对象
	/**
	 * 在构造方法中为conn对象实例化，可以直接取得数据库的连接对象
	 * 由于说有的操作都是基于数据库完成的，所以如果数据库连接失败，那么所有的后续操作也就没有意义了
	 */
	public DatabaseConnection() {
		try {
			Class.forName(DBDRIVER); //加载驱动程序
			this.conn = DriverManager.getConnection(DBURL, DBUSER, PASSWORD); //连接数据库
		} catch (Exception e) {
			e.printStackTrace(); //这个异常抛出的意义不大
		} 
	}
	/**
	 * 取得一个数据的连接对象
	 * @return Connection实例化对象
	 */
	public Connection getConnection() {
		return this.conn; //返回本类对象中的Connection对象
	}
	/**
	 * 关闭数据库
	 */
	public void close() {
		if(this.conn != null) { //表示现在有连接对象
			try {
				this.conn.close();
			} catch (SQLException e) {
				e.printStackTrace();
			}
		}
	}
}
一个小测试
数据库中表结构以及表内容


使用Test类输出表smalltest中的值

package com.fs.dbc;

import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

public class Test {
	public static void main(String[] args) throws SQLException {
		DatabaseConnection dbc = new DatabaseConnection();
		if (dbc.getConnection() != null) {
			System.out.println("success");
			// 创建statement类对象，用来执行SQL语句
			Statement statement = dbc.getConnection().createStatement();
			String sql = "select * from smalltest"; // 要执行的SQL语句
			ResultSet rs = statement.executeQuery(sql);// ResultSet类，用来存放获取的结果集
			int id = 0; //
			while (rs.next()) {
				id = rs.getInt("id");// 获取id这列数据
				System.out.println(id);// 输出
			}
		} else {
			System.out.println("f");
		}
	}
}
输出结果


成功~~
o(*￣▽￣*)ブ 开心
φ(゜▽゜*)♪高兴 
 (‾◡◝)骄傲