今天完成的事情：

1.jdbctemplate批量操作和jdbctemplate单条数据的操作复习

2.增强for循环学习

1.jdbctemplate批量操作和jdbctemplate单条数据的操作复习

 今天把jdbctemplate批量操作完成，具体的代码和实现如下：

（1）项目结构如下：

（2）接口MyDao代码如下：

package com.MyDao.Dao;
import com.MyDao.My.My;
import javax.sql.DataSource;
import java.util.List;

public interface MyDao {
    public void setDataSource(DataSource ds);
    public  List<My> listMys();

    public void create(String name,String password);

    public void addBath(final List<My> Mys);

    public void update(String name,int id);

    public void batchUpdate(final List<My> Mys);

    public void delete(int id);

    public void deleteBatch(final List<My> Mys);
    
}

（3）实体类My代码如下：

package com.MyDao.My;

public class My {
    private int id;
    private String name;
    private String password;

    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 String getPassword() {
        return password;
    }

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

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

（4）类MyMapper

package com.MyDao.My;
import org.springframework.jdbc.core.RowMapper;
import java.sql.ResultSet;
import java.sql.SQLException;

public class MyMapper implements RowMapper<My> {
    @Override
    public My mapRow(ResultSet resultSet, int i) throws SQLException {
        My my = new My();
        my.setId(resultSet.getInt("id"));
        my.setName(resultSet.getString("name"));
        my.setPassword(resultSet.getString("password"));
        return my;
    }
}

（4）实现类MyJdbcTemplate

package com.MyDao.MyJdbcTemplate;
import com.MyDao.Dao.MyDao;
import com.MyDao.My.My;
import com.MyDao.My.MyMapper;
import org.springframework.jdbc.core.BatchPreparedStatementSetter;
import org.springframework.jdbc.core.JdbcTemplate;
import javax.sql.DataSource;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.util.List;

public class MyJdbcTemplate implements MyDao{
    private DataSource dataSource;
    private JdbcTemplate jdbcTemplate;

    @Override
    public void setDataSource(DataSource dataSource) {
        this.dataSource = dataSource;
        this.jdbcTemplate = new JdbcTemplate(dataSource);

    }
    @Override
    public void create(String name,String password) {                    //单条插入数据方法
        String sql = "insert into students(name,password)values(?,?)";
        jdbcTemplate.update(sql,name,password);
        System.out.println(name +"password =" + password);
    }

    @Override
    public void delete(int id) {                                         //单条删除数据方法
        String sql = "delete from students where id = ?";
        jdbcTemplate.update(sql,id);
    }

    @Override
    public void update(String name,int id) {                          //单条更改数据方法
        String sql = "update students set name =?  where id = ?";
        jdbcTemplate.update(sql, name,id);
    }

    @Override                                                            //查询数据方法
    public List<My> listMys() {
        String sql = "select * from students";
        List<My>mys = jdbcTemplate.query(sql,new MyMapper());
        return mys;
    }

    @Override                                                            //批量插入数据方法
    public void addBath(final List<My> Mys) {
//       final List<My> mys = Mys;
        final String sql = "insert into students(name,password)values(?,?)";
        jdbcTemplate.batchUpdate(sql, new BatchPreparedStatementSetter() {
            @Override
            public void setValues(PreparedStatement preparedStatement, int i) throws SQLException {
                preparedStatement.setString(1,Mys.get(i).getName());
                preparedStatement.setString(2,Mys.get(i).getPassword());
            }

            @Override
            public int getBatchSize() {
                return Mys.size();
            }
        });
        System.out.println("插入数据成功！！");
    }

    @Override                                                             //批量删除数据方法
    public void deleteBatch(final List<My> Mys) {
        final String sql = "delete from students where id = ? ";
        jdbcTemplate.batchUpdate(sql, new BatchPreparedStatementSetter() {
            @Override
            public void setValues(PreparedStatement preparedStatement, int i) throws SQLException {
                preparedStatement.setInt(1,Mys.get(i).getId());
            }

            @Override
            public int getBatchSize() {
                return Mys.size();
            }
        });
        System.out.println("删除数据成功！！");
    }

    @Override                                                               //批量更改数据方法
    public void batchUpdate(final List<My> Mys) {
        String sql = "update students set name = ?  where id = ?";
        jdbcTemplate.batchUpdate(sql, new BatchPreparedStatementSetter() {
            @Override
            public void setValues(PreparedStatement preparedStatement, int i) throws SQLException {
                preparedStatement.setString(1,Mys.get(i).getName());
                preparedStatement.setInt(2,Mys.get(i).getId());
            }

            @Override
            public int getBatchSize() {
                return Mys.size();
            }
        });
        System.out.println("更改数据成功！！");
    }
}

（5）测试类代码如下：

package com.MyDao.MyJdbcTemplate;
import com.MyDao.My.My;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import java.util.ArrayList;
import java.util.List;

public class Test {
    public static void main(String[]args){
        ApplicationContext context = new ClassPathXmlApplicationContext("cation.xml");
        MyJdbcTemplate myJdbcTemplate = (MyJdbcTemplate)context.getBean("MyJdbcTemplate");

        System.out.println("------插入操作--------");               //单条插入数据
        myJdbcTemplate.create("校长","058");
        myJdbcTemplate.create("组长", "119");
        myJdbcTemplate.create("班长", "520");

        System.out.println("-------删除数据-------");              //单条删除数据
        myJdbcTemplate.delete(5);

        System.out.println("-------更改数据-------");              //单条更改数据
        myJdbcTemplate.update("小三",10);

        List<My> select = myJdbcTemplate.listMys();               //调用查询方法
        System.out.println("查询");
        for (My my : select) {
            System.out.print("ID : " + my.getId());
            System.out.print(">>Name : " + my.getName());
            System.out.println(">>password :"  + my.getPassword());
        }
//        以下是批量操作
        My my1 = new My();
        my1.setName("二哈");
        my1.setPassword("550");

        My my2 = new My();
        my2.setName("藏奥");
        my2.setPassword("999");

        List<My> mysAdd = new ArrayList<>();
        mysAdd.add(my1);
        mysAdd.add(my2);

        myJdbcTemplate.addBath(mysAdd);                   //调用批量插入数据的方法
        List<My>addStudents = myJdbcTemplate.listMys();
        System.out.println("批量插入：");
        for (My my3 : addStudents) {
            System.out.print("name : " + my3.getName());
            System.out.println(", password : " + my3.getPassword());
        }



        My my4 = new My();
        my4.setId(29);
        My my5 = new My();
        my5.setId(30);
        My my6 = new My();
        my6.setId(31);

        List<My> mysDelete = new ArrayList<>();
        mysDelete.add(my4);
        mysDelete.add(my5);
        mysDelete.add(my6);

        myJdbcTemplate.deleteBatch(mysDelete);             //调用批量删除数据的方法
        List<My>deleteStudents = myJdbcTemplate.listMys();
        System.out.println("批量删除");
        for (My my7 : deleteStudents) {
        }

        My my8 = new My();                              //创建新的对象，并给其设置属性值
        my8.setId(26);
        my8.setName("张亚强");

        My my9 = new My();
        my9.setId(27);
        my9.setName("张强");

        My my10= new My();
        my10.setId(28);
        my10.setName("王强");

        List<My> mys = new ArrayList<>();
        mys.add(my8);                                         //添加新的元素
        mys.add(my9);
        mys.add(my10);

        myJdbcTemplate.batchUpdate(mys);                      //调用批量更改数据的方法

        List<My>updateStudents = myJdbcTemplate.listMys();   //下面的代码只是为了显示更改操作的结果
        System.out.println("update");
        for (My my11 : updateStudents) {                     // for(a b:c) 增强for循环，将a类型的集合c中的所有元素赋值给b
            System.out.print("ID : " + my11.getId());
            System.out.println(", Name : " + my11.getName());
        }
    }
}

（6）cation.xml

<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/jdbc" />
<property name="username" value="root" />
<property name="password" value="0214" />
</bean>

<bean id="MyJdbcTemplate" class="com.MyDao.MyJdbcTemplate.MyJdbcTemplate">
<property name="dataSource" ref="dataSource"></property>
</bean>

执行单条插入数据：

数据库里面插入成功：

执行单条删除数据：

查询数据库id为5的数据被删除：

执行单条更改数据：

查询数据库id为10的数据被更改：

执行查询数据：

查询结果：

批量插入数据：

查询数据库插入成功：

批量删除数据：

查询数据库id为29,30,31的数据被删除：

批量更改数据：

查询数据库id为26,27,28的数据被更改：

2.增强for循环学习

foreach的书写格式：

for（元素类型  元素名称 ： 遍历数组（集合）（或者能进行迭代的））{

语句}

在今天jdbctemplate批量操作中也用到了增强for循环：

 for (My my11 : updateStudents) { // for(a b:c) 增强for循环，将a类型的集合c中的所有元素赋值给b
           System.out.print("ID : " + my11.getId());
           System.out.println(", Name : " + my11.getName());

我们看看下面的例子：

public static void main(String[] args) {

  List<String> arr = new ArrayList<String>();

  arr.add("你好");

  arr.add("我好");

  arr.add("大家好");

  //foreach循环

  for(String str : arr){     　　//这里的str就是为了获取每次循环的arr中的值

   System.out.println(str);   　　　 //就相当于 String str=arr[i]

  }

 }

但是相比较之下我们用for循环输入就略显麻烦

public static void main(String[] args) {

  List<String> arr = new ArrayList<String>();

  arr.add("你好");

  arr.add("我好");

  arr.add("大家好");  

  //for循环

  for(int i=0;i<arr.size();i++){

   System.out.println(arr.get(i)); //要获取list中元素需要用get方法 

  }

 }

 总结下来：

增强for循环变量元素的过程中不准使用集合。

foreach适用于只是进行集合或数组遍历，for则在较复杂的循环中效率更高。

foreach不能对数组或集合进行修改（添加删除操作），如果想要修改就要用for循环。

for循环更为灵活。

明天计划的事情：

   明天早上把jdbctemplate批量操作的代码再敲一遍，学习连接池，开始进行mybatis连接数据库的任务。

遇到的问题：

  今天在进行jdbctemplate批量更改数据操作的时候由于没有注意到逻辑的顺序关系导致程序执行后batchUpdate方法一直没有执行，代码也没有提示错误，导致我一直找不到错误出现在哪，之后请教亚博师兄后找出错误，现在错误已解决，具体的错误如下：

  public void batchUpdate(final List<My> Mys) {
        String sql = "update students set name = ?  where id = ?";
        jdbcTemplate.batchUpdate(sql, new BatchPreparedStatementSetter() {
            @Override
            public void setValues(PreparedStatement preparedStatement, int i) throws SQLException {
                preparedStatement.setString(1,Mys.get(i).getName());
                preparedStatement.setInt(2,Mys.get(i).getId());
//                preparedStatement.setInt(1,Mys.get(i).getId());        //错误的代码
//                preparedStatement.setString(2,Mys.get(i).getName());  
            }

            @Override
            public int getBatchSize() {
                return Mys.size();
            }
        });
        System.out.println("更改数据成功！！");
    }

   错误在于sql语句应该先设置name的值，后设置id的值，当时我是代码顺着敲下来没注意到这个逻辑顺序，先设置了id的值，后设置了name的值，所以导致方法一直不能被执行，吃一堑长一智吧，虽然这是个小坑，但也浪费了近两个小时的时间，以后敲代码的时候一定要仔仔细细。

收获：

 今天复习了jdbctemplate的单条数据的增删改查的操作，温故而知新，回头复习代码一遍，可以得到不少的东西:

 (1)sql语句的复习：

增加数据的语句：insert into students(name,password)values(?,?)

删除数据的语句：delete from students where id = ?

更改数据的语句：update students set name =?  where id = ?

查询数据的语句：（全表查询）select * from students  也可以进行条件查询：select * from students where id= ？

（2）可以在查询操作的时候将students表内的属性封装在类MyMapper并让其实现类RowMapper，这样做的好处还未能明白。

实现了jdbctemplate批量操作，发现其都是通过

 public void deleteBatch(final List<My> Mys) {

        final String sql = "delete from students where id = ? ";

        jdbcTemplate.batchUpdate(sql, new BatchPreparedStatementSetter() {

            @Override

            public void setValues(PreparedStatement preparedStatement, int i) throws SQLException {

                preparedStatement.setInt(1,Mys.get(i).getId());

            }

            @Override

            public int getBatchSize() {

                return Mys.size();

            }

        });}

这样的方法格式进行批量操作的。

增强for循环：

for(a b:c) 增强for循环，将a类型的集合c中的所有元素赋值给b

       My my4 = new My();

       my4.setId(29);

       My my5 = new My();

       my5.setId(30);

       My my6 = new My();

       my6.setId(31);

       List<My> mysDelete = new ArrayList<>();

       mysDelete.add(my4);

       mysDelete.add(my5);

       mysDelete.add(my6);

       myJdbcTemplate.deleteBatch(mysDelete);             //调用批量删除数据的方法

       List<My>deleteStudents = myJdbcTemplate.listMys();

       System.out.println("批量删除");

       for (My my7 : deleteStudents) {

}

  上面的代码中就是讲My类型中集合deleteStudents中元素my4，my5，my6依次赋值给my7，因为增强for循环会遍历目标，遍历的目标是deleteStudents，所以它会将所以的元素都依次赋值给my7。