JDBCTemplate 研究两天，断网两天。。日报就拖到现在了。

子任务17：

终于到了 真正的编码时刻。
这个子任务目的是 让我看看Java里面是怎么来操作数据库的。

先来Mybatis：

建好lib文件夹，放入Mybatis的Jar包 和 Java链接数据库的jar包。
一个 用来连接数据库的xml。
建一个 和数据表 结构一模一样的 类，用来承载获取的数据库data。
建一个 sql操作的xml。
建一个 执行sql操作的 类。
以上建好之后，变成这样：

下面详细写下，这几个文件的写法。
首先是用来装数据表的Test1类。

package com.park.test1;
public class Test1 {
 private int id;
 private String name;
 private int score;
 
 public int getId() {
  return id;
 }
 
 public void setId(int id) {
  this.id = id;
 }
 
 public String getName() {
  return name;
 }
 
 public void setName(String name) {
  this.name = name;
 }
 
 public int getScore() {
  return score;
 }
 public void setScore(int score){
  this.score = score;
 }
 
 @Override
 public String toString() {
  return "User [id=" + id + ", name=" + name + ", score=" + score + "]";
 }
}

可以看到，这个类里面 每个成员都和数据表一一对应。感觉最后一个重写很精髓，打印这个成员时候，直接把所有数据都给你打印出来了。

然后是连接数据库的xml。

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC" />
            <!-- 配置数据库连接信息 -->
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver" />
                <property name="url" value="jdbc:mysql://localhost:3306/test" />
                <property name="username" value="root" />
                <property name="password" value="123456" />
            </dataSource>
        </environment>
    </environments>
   
    <mappers>
    <mapper resource="com/park/mapping/userMapper.xml"/>
    </mappers>
   
</configuration>

这个xml主要是设置一下和数据库连接的一些 口令啊。
值得注意的是，这个xml包含一个mappers，这个mappers的地址是一个绑定Sql操作的xml。
也就是这个

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!-- 为这个mapper指定一个唯一的namespace，namespace的值习惯上设置成包名+sql映射文件名，这样就能够保证namespace的值是唯一的
例如namespace="me.gacl.mapping.userMapper"就是me.gacl.mapping(包名)+userMapper(userMapper.xml文件去除后缀)
 -->
<mapper namespace="com.park.mapping.userMapper">
    <!-- 在select标签中编写查询的SQL语句， 设置select标签的id属性为getUser，id属性值必须是唯一的，不能够重复
    使用parameterType属性指明查询时使用的参数类型，resultType属性指明查询返回的结果集类型
    resultType="me.gacl.domain.User"就表示将查询结果封装成一个User类的对象返回
    User类就是users表所对应的实体类
    -->
    <!--
        根据id查询得到一个user对象
     -->
    <select id="getUser" parameterType="int"
        resultType="com.park.test1.Test1">
        select * from student where id=#{id}
    </select>
</mapper>

xml的select标签之前没见过，学习了。
最后一个文件是 执行Sql的类，如下。

package com.park.test;
import java.io.IOException;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import java.io.InputStream;
import com.park.test1.Test1;
public class Dosql {
public static void main(String[] args) throws IOException{
 String resource = "conf.xml";
 
 InputStream is = Dosql.class.getClassLoader().getResourceAsStream(resource);
 
 SqlSessionFactory sessionFactory = new SqlSessionFactoryBuilder().build(is);
 
 SqlSession session = sessionFactory.openSession();
 
 String statement = "com.park.mapping.userMapper.getUser";
 
 Test1 user = session.selectOne(statement, 2);
 System.out.println(user);
}
}

这个文件感觉好复杂，将前面的3个文件串起来了。前三句是设置Sql事务参数。第四句通过设置完参数的事务工厂把 事务对象创建出来。第五句指定 Sql操作的XML。第六句 将string形式的xml地址传给，事务对象，并执行，返回一个 Test1类的对象。打印Test1对象。
以上都是我瞎编的，有点复杂的流程，得死记再好好消化。

之前的胡诌是因为当时我见的太少（虽然现在我也不多。。），实际上这只是用Mybatis框架，而实现一个 反射而已。 Java里面类似的写法很多。像 JDBCTemplate差不多也是这么写的。 区别在于 JDBCTemplate 用来执行的SQL操作 写成了DAO，而Mybatis是写成了XML。 所以 问题17里面的Mybatis为什么不用 impl 的原因，是不是 因为Mybatis 的XML不像Java的Class 写不了impl？

接下来是 JDBCTemplate 的Dao写法。

恕我愚钝，网上教程翻了2天，加上N次尝试，才知道怎么写。

JDBCTemplate 是Spring框架里面的一个小模块。 

要想写简单的话（不用Dao，基本上，2个文件就能写完了）

就像这样（哦，3个文件）：

db.properties是用来写数据库配置的：

jdbc.user=root
jdbc.password=123456
jdbc.driverClass=com.mysql.jdbc.Driver
jdbc.jdbcUrl=jdbc\:mysql\:///test

applicationContext.xml 是Spring框架（还是JDBCTemplate？）的一个 用来配置Beans 的一个XML：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-2.5.xsd">
<context:property-placeholder location="classpath:db.properties"/>
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
    <property name="user" value="${jdbc.user}"></property>
    <property name="password" value="${jdbc.password}"></property>
    <property name="driverClass" value="${jdbc.driverClass}"></property>
    <property name="jdbcUrl" value="${jdbc.jdbcUrl}"></property>
</bean>

<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
    <property name="dataSource" ref="dataSource"></property>
</bean>
</beans>

最后是执行文件

package me.flyingming.test3;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.jdbc.core.JdbcTemplate;

/**
 * Hello world!
 *
 */
public class App
{
    public static void main( String[] args )
    {
     //启动IoC容器
     ApplicationContext ctx=new ClassPathXmlApplicationContext("applicationContext.xml");
     //获取IoC容器中JdbcTemplate实例
     JdbcTemplate jdbcTemplate=(JdbcTemplate) ctx.getBean("jdbcTemplate");
     String sql="insert into student (name,score) values (?,?)";
     int count= jdbcTemplate.update(sql, new Object[]{"caoyc",3});
     System.out.println(count);
    }
}

这个文件写法 看起来和 Mybatis差不多。这是一个非常简单的例子，  直接用了JDBCTemplate的方法，并没有将其封装成 Dao。 执行的result 也没有用一个 Class来接受。

下面是一个标准一点的例子。

和上面简单例子的区别就是， 多了两个类，一个是 和数据库对应的类（行话为“数据库表映射类”），一个是Dao。

关注一下，这个执行类的写法：

package me.flyingming.test5;

import me.flyingming.dao.StudentDao;
import me.flyingming.student.Student;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * Hello world!
 *
 */
public class App {
 public static void main(String[] args) {
  ApplicationContext context = new ClassPathXmlApplicationContext(
    "applicationContext.xml");
  
  StudentDao studentDao = (StudentDao) context.getBean("studentDao");
  
  Student student1 = new Student(1,"gaoming",99);
  
  studentDao.insertStudent(student1);
  
  studentDao.updateStudent(1,22);

 }
}

可以看到，非常简洁。Sql的执行语句绑定在Dao的一个个方法里面了。执行也太简单了，将数据当做Dao方法的参数，执行完成了，那边数据库就会有相应的操作了（增删改查）。

JDBCTemplate我还得仔细回味一下。

另：网上服务器好贵。准备自己搭服务器的， 我这个路由器 带有DDNS服务，可以用来动态绑定网络地址。BUT，这个鬼路由器 是房东的，不能获取里面 软件的权限包括DDNS。 好烦，看来还是得买 云服务器了。。

今天完成的事情：了解了Mybatis和JDBCTemplate编码的一些知识                        
明天计划的事情：Spring框架的一些知识，和Junit单元测试的一些知识
遇到的问题：对于 JDBCTemplate 和 Bean 一些概念并不 熟悉，还得 多揣摩                           
收获：了解了 一些 JDBCTemplate的特性（Spring），什么的。