今日完成

1.使用idea连接数据库：

1）新建数据库jnshu 表jdbc_user 属性：id，username,password;

2）学习使用基础的jdbc连接查询过程：

import java.sql.*;

public class TestTemp {
//                                                抓取异常抛出 class未找到/SQL异常，两个都需要抓取，不然报错！！
//                                                 Unhandled exception: java.sql.SQLException!
   public static void main(String[] args) throws ClassNotFoundException,SQLException {
//        创建连接对象 右alt+ent 自动导包
       Connection conn;
//        创建驱动程序
       String driver = "com.mysql.jdbc.Driver";
//        创建数据库连接
       String url = "jdbc:mysql://localhost:3306/jnshu";
//        配置用户名密码
       String sqlname = "root";
       String password= "root";
//        加载驱动程序
       Class.forName(driver);

//        获得数据库连接
       conn = DriverManager.getConnection(url,sqlname,password);

           String sql = "select * from jdbc_user";
//        String sql = "insert into jdbc_user(iname,password) values ('123','123')";

//        向数据库发送sql语句，用于执行不带参数的简单SQL语句
       Statement stmt = conn.createStatement();
//        PreparedStatement pstmt = conn.prepareStatement(sql) ;


//        查询结果集，这里返回的是一个结果集！while或者for遍历输出
       ResultSet rs = stmt.executeQuery(sql);
//        循环输出
       while(rs.next()){
System.out.print(rs.getString("name")+","+ rs.getString("password"));
       }

//        测试执行顺序！
       System.out.println("我是1");

//        关闭连接
       rs.close();
       stmt.close();
       conn.close();
   }
}

结果：

章则,133我是1

Process finished with exit code 0

（出现过一次乱码，原来是数据库默认的编码不是UTF-8，修改后重新建库未出现乱码）

问题1：DriverManger报错！（其它的需要加载项也有类似问题，比如Statement）

jar包加载过，数据库驱动也加载好了，都试了一遍，依然不行。测试其它接口方法也无法自动导入包。

解决：删除java文件，重启以后重新加载jar包，使用idea自动提示加载的去写出来，而不是直接手打DriverManager。

问题2：throw  ClassNotFoundException  和  SQLException；

public static void main(String[] args) throws ClassNotFoundException,SQLException {     ... }

直接main方法会报错，不知道具体在方法内部什么地方try，尝试把方法全包含进去。

解决：可以在main后面throws抓取异常。

但是异常是怎么出现的/出现在哪一个节点，这样是交给哪一步去处理了，和在内部try{}catch{}有什么区别？

问题3：

while(rs.next()){
           System.out.print(rs.getString("name")+","+ rs.getString("password"));
       }
//        测试执行顺序！
       System.out.println("我是1");

执行结果：

注意了下执行顺序的问题，while明显是在 "我是1”后面输出。是因为它们同步进行的么，while执行的多所以在后面。还是因为while先执行，然后没有执行完的时候继续执行后面的。这算是java里内部处理的多线程吗？

2.idea jdbcTemplate数据库连接和xml里bean的配置

目录树：

Dao.java：

package dao;

import pojo.User;

import java.util.List;

public interface Dao {

List<User> findAllUser();

   void Create(User user);
   void Update(User user);
   void Delect(int id);

}

DaoImpl.java:

package daoImpl;

import dao.Dao;
import pojo.User;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowCallbackHandler;

import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;

public class DaoImpl implements Dao {

private JdbcTemplate jdbcTemplate;

   public JdbcTemplate getJdbcTemplate() {
return jdbcTemplate;
   }

public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
this.jdbcTemplate = jdbcTemplate;
   }

public void Create(User user) {
//        ？？？可以直接用jdbctemplate里方法后面传参直接替换
       String sql = "insert into jdbc_user values(?,?,?)";
       jdbcTemplate.update(sql,user.getId(),user.getUsername(),user.getPassword());
   }

public void Update(User user) {
String sql = "update jdbc_user set username=?,password=? where id = ?";
       jdbcTemplate.update(sql,user.getUsername(),user.getPassword(),user.getId());
   }

public void Delect(int id) {
String sql = "delect from jdbc_user where id = ?";
       jdbcTemplate.update(sql,id);
   }

public List<User> findAllUser() {

String sql = "select * from jdbc_user";
//        添加为final是为了在RowCallbackHandler里可以调用！不添加不能在里面add(user)!
//        不可以写在 processRow(ResultSet rs) {里面}，不然外面无法调用！
       final List<User> list =new ArrayList<User>();
       jdbcTemplate.query(sql, new RowCallbackHandler() {

public void processRow(ResultSet rs) throws SQLException {
User user = new User();
               user.setId(rs.getInt("id"));
               user.setUsername(rs.getString("username"));
               user.setPassword(rs.getString("password"));
               list.add(user);
           }
});

       return list;
   }
}

实体类：

package pojo;
import dao.Dao;
public class User {

private int id;
   private String username;
   private String password;
   private Dao dao;

   public int getId() {
return id;
   }

public void setId(int id) {
this.id = id;
   }

public String getUsername() {
return username;
   }

public void setUsername(String username) {
this.username = username;
   }

public String getPassword() {
return password;
   }

public void setPassword(String password) {
this.password = password;
   }

public Dao getDao() {
return dao;
   }

public void setDao(Dao dao) {
this.dao = dao;
   }

@Override
   public String toString() {
return "User{" +
"id=" + id +
", username='" + username + '\'' +
", password='" + password + '\'' +
'}';
   }
}

bean/xml：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
      xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
   <!--配置jdbcTemplate  数据源！ -->
   <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
       <property name="dataSource" ref="dataSource"/>
   </bean>
   <!--配置数据库连接 -->
   <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
       <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
       <property name="url" value="jdbc:mysql://localhost:3306/jnshu" />
       <property name="username" value="root" />
       <property name="password" value="root" />
   </bean>

   <!--总算明白name是DapImpl里的jdbcTemplate值为jdbcTemplate（ref为对象，value为值）-->
   <bean id="DaoImpl" class="daoImpl.DaoImpl">
       <property name="jdbcTemplate" ref="jdbcTemplate"></property>
   </bean>


</beans>

依赖注入：“依赖注入(Dependency Injection)和控制反转(Inversion of Control)是同一个概念。具体含义是:当某个角色(可能是一个Java实例，调用者)需要另一个角色(另一个Java实例，被调用者)的协助时，在传统的程序设计过程中，通常由调用者来创建被调用者的实例。但在Spring里，创建被调用者的工作不再由调用者来完成，因此称为控制反转;创建被调用者 实例的工作通常由Spring容器来完成，然后注入调用者，因此也称为依赖注入。所谓依赖注入，是指程序运行过程中，如果需要调用另一个对象协助时，无须在代码中创建被调用者，而是依赖于外部的注入。Spring的依赖注入对调用者和被调用者几乎没有任何要求，完全支持对POJO之间依赖关系的管理。”

依赖注入最常用的有两种方式：属性注入和构造方法注入

bean就是依赖注入中的依赖属性，一旦在配置文件中配置bean映射，则配置的这个class就会被注入到Spring容器中，我们可以在程序中直接只用这个类，比如@Autowired为什么能够自动写入get/set方法，就是因为当前类已经注入到Spring容器中了， 当然我们也可以在程序中通过id（不通过Spring容器），找到类对应的对象，去处理相关的东西 。

比如

<bean id="dao" class="DaoImpl.DaoImpl">
   <property name="six" value="jds"></property>
</bean>

中，id"dao"是唯一的，class就是它指向的java文件。property里，name和value就是指上面的java文件里名为‘six’的属性的值是“jds”。

property:name属性可以定义新的bean(ref),也可以定义新的值（value）;

问题:

关于RowCallbackHandler报错调用不到，无法导入，同样是有jar包的，引入了调用不到。手打也是，经常会出现这种情况。和eclipse不一样，idea需要配置很多东西，所以感觉很多地方对新人都不友好，查询這些消耗了太多时间。

关于jar包的导入：Project Structure——Libraries—— +号添加。然后Build！要jar包出现在下面的External Libraries里。

这里jar包可以导入，可以new对象，但是无法使用对象里的方法：

把项目关了，删了.idea重启idea，重新写dao。

重复了N遍，最后不报错了。

findAllUser没有报错：

public List<User> findAllUser() {

String sql = "select *from jdbc_user";
//        添加为final是为了在RowCallbackHandler里可以调用！不添加不能在里面add(user)! 
//        不可以写在 processRow(ResultSet rs) {里面}，不然外面无法调用！
      final List<User> list =new ArrayList<User>();
       jdbcTemplate.query(sql, new RowCallbackHandler() {

public void processRow(ResultSet rs) throws SQLException {
               User user = new User();
               user.setId(rs.getInt("id"));
               user.setUsername(rs.getString("username"));
               user.setPassword(rs.getString("password"));
               list.add(user);
           }
});

       return list;
   }

虽然写了，但是总是报错，创建接口对象的方法一直没办法调用。

=================================================

总结下步骤：配置好maven和本地库，创建maven项目（保证网络）—— 初始启动idea的时候ctrl+shift+F10 编译运行一下，创建的java文件夹，要在Project Structure—Modules—Source里设置为编译项（Source），不然不能创建java文件 —— 然后倒入需要的jar包 —— 写class的时候要让它自动生成！补全功能！不然就报错（已经开了自动导入，也build了）。

·奇迹，回家重新写了一遍，直接就编译成功了，有种莫名的冲动…

目录：

结构同上，User类里添加了调用dao接口的方法。然后执行：

总结：

本来在Eclipse里都好好的，但是一用idea就到处都是错，找不到原因就写不下去，脑子都成一团浆糊了。最大的体会就是思路很重要，报错越多脑子越乱。今天对比昨天基本上只是增加了熟练度。

主要完成的事情和收获：

·学习在idea里写了一遍基础的 jdbc连接，直接在方法里写连接，不用xml依赖注入。感觉对比JDBCTemplate来说基础的jdbc很多东西都在一起，每次使用都要打开数据库连接，然后传值，关闭。JDBCTemplate是有明显的分工，只要写好接口，有需要的直接使用依赖修改就可以，灵活很多。；

·修改了乱码的问题（数据库和idea）；

·明白了bean的属性对应的问题；pom的配置还不明白；

·final常量的理解加深（作用域）；

·一些异常的处理（还不是太清楚，只是知道有这样一种方式可以处理异常）：

 throws ClassNotFoundException,SQLException

·在实体类里面可以new接口，然后通过接口调用实现类里面的方法！

User.java:

package user;

import userDao.UserDao;

import java.util.List;

public class User {

private int id;
   private String name;
   private String password;
//UserDao接口
   private UserDao userdao;

  ……略

public List<User> findAllUser(){
       return userdao.findAllUser();
   }



@Override
   public String toString() {
return "User{" +
"id=" + id +
", name='" + name + '\'' +
", password='" + password + '\'' +
'}';
   }
}

·代码写的明显快了些

·基础很不扎实，不知道用什么接口去调用什么方法。

明天计划：

1.mybatis创建项目

2.可以的话在基础jdbc里往下延伸，了解 Connection连接对象；  DriverManager 驱动如何获取连接数据库；PreparedStatement.getConnection(url,sqlname,password)事务的使用；

close()关闭方法；

明日继续，只要进步。