JDBC上

JDBC实战--打通数据库

代码实现：

 1 package com.imooc.db;
 2 
 3 import java.sql.Connection;
 4 import java.sql.DriverManager;
 5 import java.sql.ResultSet;
 6 import java.sql.SQLException;
 7 import java.sql.Statement;
 8 
 9 import com.imooc.model.Goddess;
10 
11 public class DBUtil {
12 
13     private static final String URL = "jdbc:mysql://127.0.0.1:3306/imooc?useUnicode=true&amp;characterEncoding=utf-8";
14     private static final String USER = "root";
15     private static final String PASSWORD = "123456";
16 
17     public static void main(String[] args) throws Exception {
18         // 1.加载驱动程序
19         Class.forName("com.mysql.jdbc.Driver");// 反射机制，通过一个类名去反向的将这个类加载到我们的环境中
20         // 2.获得数据库的连接
21         Connection conn = DriverManager.getConnection(URL, USER, PASSWORD);// DriverManager驱动类
22         // 3.通过数据库的连接操作数据库，实现增删改查
23         Statement stmt = conn.createStatement();
24         // 执行查询，返回ResultSet对象
25         ResultSet rs = stmt
26                 .executeQuery("select user_name,age from imooc_goddess");
27         // rs.next()返回的是true，证明对象rs里面有数据
28         while (rs.next()) {
29             // 如果对象rs里面有数据，就会循环打印出来，如果没有，这个循环就不会走
30             System.out.println(rs.getString("user_name") + ","
31                     + rs.getInt("age"));
32         }
33 
34     }
35 }

数据库数据

imooc/imooc_goddess

运行结果：

测试数据库连接成功，能够从数据库读取到数据。

控制台输出

模型（三层架构）主要包括两个部分：对应数据库映射、对数据库映射的抽象方法（CRUD：增、删、改、查）

控制层：控制数据流通过程。把数据拼装起来，展示给视图层

视图层：对数据的展示

模型层：数据处理，业务逻辑

把视图层的展示、业务逻辑、数据存储的过程分离开来，通过控制层来协调控制。

视图层：是用来数据展示用的，为了给用户展示出程序运行的结果

控制层（Controller）：更新模型层，更新视图层

java基础——静态块：静态块执行的是最早的

JDBC实战--搭建模型层（DAO层）

数据库对应的实体类

  1 package com.imooc.model;
  2 
  3 import java.util.Date;
  4 
  5 public class Goddess {
  6 //这些属性分别对应数据库的字段
  7     private Integer id;
  8     private String user_name;
  9     private Integer sex;
 10     private Integer age;
 11     private Date birthday;
 12     private String email;
 13     private String mobile;
 14     private String create_user;
 15     private String update_user;
 16     private Date create_date;
 17     private Date update_date;
 18     private Integer isdel;
 19 
 20     public Integer getId() {
 21         return id;
 22     }
 23 
 24     public void setId(Integer id) {
 25         this.id = id;
 26     }
 27 
 28     public String getUser_name() {
 29         return user_name;
 30     }
 31 
 32     public void setUser_name(String user_name) {
 33         this.user_name = user_name;
 34     }
 35 
 36     public Integer getSex() {
 37         return sex;
 38     }
 39 
 40     public void setSex(Integer sex) {
 41         this.sex = sex;
 42     }
 43 
 44     public Integer getAge() {
 45         return age;
 46     }
 47 
 48     public void setAge(Integer age) {
 49         this.age = age;
 50     }
 51 
 52     public Date getBirthday() {
 53         return birthday;
 54     }
 55 
 56     public void setBirthday(Date birthday) {
 57         this.birthday = birthday;
 58     }
 59 
 60     public String getEmail() {
 61         return email;
 62     }
 63 
 64     public void setEmail(String email) {
 65         this.email = email;
 66     }
 67 
 68     public String getMobile() {
 69         return mobile;
 70     }
 71 
 72     public void setMobile(String mobile) {
 73         this.mobile = mobile;
 74     }
 75 
 76     public String getCreate_user() {
 77         return create_user;
 78     }
 79 
 80     public void setCreate_user(String create_user) {
 81         this.create_user = create_user;
 82     }
 83 
 84     public String getUpdate_user() {
 85         return update_user;
 86     }
 87 
 88     public void setUpdate_user(String update_user) {
 89         this.update_user = update_user;
 90     }
 91 
 92     public Date getCreate_date() {
 93         return create_date;
 94     }
 95 
 96     public void setCreate_date(Date create_date) {
 97         this.create_date = create_date;
 98     }
 99 
100     public Date getUpdate_date() {
101         return update_date;
102     }
103 
104     public void setUpdate_date(Date update_date) {
105         this.update_date = update_date;
106     }
107 
108     public Integer getIsdel() {
109         return isdel;
110     }
111 
112     public void setIsdel(Integer isdel) {
113         this.isdel = isdel;
114     }
115 
116     @Override
117     public String toString() {
118         return "Goddess [id=" + id + ", user_name=" + user_name + ", sex="
119                 + sex + ", age=" + age + ", birthday=" + birthday + ", email="
120                 + email + ", mobile=" + mobile + ", create_user=" + create_user
121                 + ", update_user=" + update_user + ", create_date="
122                 + create_date + ", update_date=" + update_date + ", isdel="
123                 + isdel + "]";
124     }
125 }

模型层：CRUD（增、删、改、查）

控制层：接收视图层的参数，调用模型层，模型层把结果通知给控制层，控制层把结果更新给视图层，展示给用户，起着桥梁的作用

新的执行sql语句的方法：预编译sql语句

测试新增女神的方法：

测试结果：

数据库更新

java.sql.Date是java.util.Date的子集

新增女神代码实现：

 1 //新增女神
 2     public void addGoddess(Goddess g) throws Exception{
 3         Connection conn=DBUtil.getConnection();//1、获得数据库连接
 4         //编译sql语句，给sql语句传递参数
 5         //2、拼写sql语句，执行SQL语句
 6         String sql="" +
 7                 "insert into imooc_goddess" +
 8                 "(user_name,sex,age,birthday,email,mobile," +
 9                 "create_user,create_date,update_user,update_date,isdel)" +
10                 "values(" +
11                 //参数用问号表示，相当于占位符，有几个参数就有几个问号，再给这些参数来进行赋值，到真正执行的时候，这些参数会加载到这个sql语句，把这个sql语句拼接完整，再去执行。这样就会减少对数据库操作
12                 //要是不用前台传递参数，可以在sql语句里面直接写入。例：current_date()
13                 "?,?,?,?,?,?,?,current_date(),?,current_date(),?)";
14         //将sql语句加载到驱动程序的执行程序中，但是并不直接执行，而是当它调用execute方法的时候才真正执行
15         //3、预编译
16         PreparedStatement ptmt=conn.prepareStatement(sql);
17             
18         //4、传参给预编译符？去赋值
19         //ptmt.setString(1,user_name);
20         //传递参数，user_name这个值不能写死，应该通过方法来传进来，这样我们就可以在视图层插入数据
21         //前台只需将值通过setter方法，就可以把数据集成的传递过来
22         ptmt.setString(1, g.getUser_name());//传递第一个参数，设置第一个?占位符的值
23         ptmt.setInt(2, g.getSex());
24         ptmt.setInt(3, g.getAge());
25         //ptmt.setDate(4, g.getBirthday());需要的参数是sql.Date类型的日期类型，但是传进来的值是java.util.Date，类型不符，需要转换
26         ////定义一个java.sql.Date类型的data，new Date(date),然后将我们的值g.getBirthday().getTime()传进去
27         //getTime() 方法可返回距 1970 年 1 月 1 日之间的毫秒数。
28         ptmt.setDate(4, new Date(g.getBirthday().getTime()));
29         ptmt.setString(5, g.getEmail());
30         ptmt.setString(6, g.getMobile());
31         ptmt.setString(7, g.getCreate_user());
32         ptmt.setString(8, g.getUpdate_user());
33         ptmt.setInt(9, g.getIsdel());
34         //5、调用execute方法的时候才真正执行
35         ptmt.execute();
36     }

新增女神功能测试：

 1 public static void main(String[] args) throws Exception {
 2         
 3         //1、测试新增女神功能
 4         GoddessDao g=new GoddessDao();
 5         
 6         //定义女神对象
 7         Goddess g1=new Goddess();
 8         
 9         g1.setUser_name("小夏");
10         g1.setAge(22);
11         g1.setSex(1);
12         g1.setBirthday(new Date());
13         g1.setEmail("xiaxia@imooc.com");
14         g1.setMobile("18766888866");
15         g1.setCreate_user("ADMIN");
16         g1.setUpdate_user("ADMIN");
17         g1.setIsdel(1);
18         
19         g.addGoddess(g1);
20     }

运行结果：

数据库表格imooc_goddess数据更新：

JDBC实战--搭建视图层

课程总结

检验代码采用MVC三层架构模式

模型层：实体类+DAO层（封装了对数据库操作的代码），和数据库打交道

Control（控制层)：负责调用模型层

View（视图层）：调用控制层

这种方式将应用程序和数据库分开了，没有中间的过程，没有中间ODBC，厂商API，也没有中间服务器，是直接和数据库打交道，所有效率上会很高。

具体代码实现：

模型层：实体类+DAO层

  1 package com.imooc.model;
  2 
  3 import java.util.Date;
  4 //模型层（实体类+DAO层：封装了对数据库操作的代码）
  5 //实体类第一个字母一定要大写
  6 public class Goddess {
  7 //这些属性分别对应数据库的字段
  8     private Integer id;
  9     private String user_name;
 10     private Integer sex;
 11     private Integer age;
 12     private Date birthday;
 13     private String email;
 14     private String mobile;
 15     private String create_user;//创建人
 16     private String update_user;//更新人
 17     private Date create_date;//创建时间
 18     private Date update_date;//更新时间
 19     private Integer isdel;//是否删除的标记。setIsdel(1):不删除
 20 
 21     public Integer getId() {
 22         return id;
 23     }
 24 
 25     public void setId(Integer id) {
 26         this.id = id;
 27     }
 28 
 29     public String getUser_name() {
 30         return user_name;
 31     }
 32 
 33     public void setUser_name(String user_name) {
 34         this.user_name = user_name;
 35     }
 36 
 37     public Integer getSex() {
 38         return sex;
 39     }
 40 
 41     public void setSex(Integer sex) {
 42         this.sex = sex;
 43     }
 44 
 45     public Integer getAge() {
 46         return age;
 47     }
 48 
 49     public void setAge(Integer age) {
 50         this.age = age;
 51     }
 52 
 53     public Date getBirthday() {
 54         return birthday;
 55     }
 56 
 57     public void setBirthday(Date birthday) {
 58         this.birthday = birthday;
 59     }
 60 
 61     public String getEmail() {
 62         return email;
 63     }
 64 
 65     public void setEmail(String email) {
 66         this.email = email;
 67     }
 68 
 69     public String getMobile() {
 70         return mobile;
 71     }
 72 
 73     public void setMobile(String mobile) {
 74         this.mobile = mobile;
 75     }
 76 
 77     public String getCreate_user() {
 78         return create_user;
 79     }
 80 
 81     public void setCreate_user(String create_user) {
 82         this.create_user = create_user;
 83     }
 84 
 85     public String getUpdate_user() {
 86         return update_user;
 87     }
 88 
 89     public void setUpdate_user(String update_user) {
 90         this.update_user = update_user;
 91     }
 92 
 93     public Date getCreate_date() {
 94         return create_date;
 95     }
 96 
 97     public void setCreate_date(Date create_date) {
 98         this.create_date = create_date;
 99     }
100 
101     public Date getUpdate_date() {
102         return update_date;
103     }
104 
105     public void setUpdate_date(Date update_date) {
106         this.update_date = update_date;
107     }
108 
109     public Integer getIsdel() {
110         return isdel;
111     }
112 
113     public void setIsdel(Integer isdel) {
114         this.isdel = isdel;
115     }
116 
117     //重写一个toString方法
118     @Override
119     public String toString() {
120         return "Goddess [id=" + id + ", user_name=" + user_name + ", sex="
121                 + sex + ", age=" + age + ", birthday=" + birthday + ", email="
122                 + email + ", mobile=" + mobile + ", create_user=" + create_user
123                 + ", update_user=" + update_user + ", create_date="
124                 + create_date + ", update_date=" + update_date + ", isdel="
125                 + isdel + "]";
126     }
127 }

  1 package com.imooc.dao;
  2 
  3 import java.sql.Connection;
  4 import java.sql.Date;
  5 import java.sql.PreparedStatement;
  6 import java.sql.ResultSet;
  7 import java.sql.SQLException;
  8 import java.util.ArrayList;
  9 import java.util.List;
 10 import java.util.Map;
 11 
 12 import com.imooc.db.DBUtil;
 13 import com.imooc.model.Goddess;
 14 //模型层（实体类+DAO层：封装了对数据库操作的代码）
 15 //执行业务方法
 16 public class GoddessDao {
 17 //新增女神
 18     public void addGoddess(Goddess g) throws Exception{
 19         Connection conn=DBUtil.getConnection();//1、获得数据库连接
 20         //编译sql语句，给sql语句传递参数
 21         //2、拼写sql语句，执行SQL语句
 22         String sql="" +
 23                 "insert into imooc_goddess" +
 24                 "(user_name,sex,age,birthday,email,mobile," +
 25                 "create_user,create_date,update_user,update_date,isdel)" +
 26                 "values(" +
 27                 //参数用问号表示，相当于占位符，有几个参数就有几个问号，再给这些参数来进行赋值，到真正执行的时候，这些参数会加载到这个sql语句，把这个sql语句拼接完整，再去执行。这样就会减少对数据库操作
 28                 //要是不用前台传递参数，可以在sql语句里面直接写入。例：current_date()
 29                 "?,?,?,?,?,?,?,current_date(),?,current_date(),?)";
 30         //将sql语句加载到驱动程序的执行程序中，但是并不直接执行，而是当它调用execute方法的时候才真正执行
 31         //3、预编译
 32         PreparedStatement ptmt=conn.prepareStatement(sql);
 33             
 34         //4、传参给预编译符？去赋值
 35         
 36         //ptmt.setString(1,user_name);
 37         //传递参数，user_name这个值不能写死，应该通过方法来传进来，这样我们就可以在视图层插入数据
 38         //前台只需将值通过setter方法，就可以把数据集成的传递过来
 39         ptmt.setString(1, g.getUser_name());//传递第一个参数，设置第一个?占位符的值
 40         ptmt.setInt(2, g.getSex());
 41         ptmt.setInt(3, g.getAge());
 42         //ptmt.setDate(4, g.getBirthday());需要的参数是sql.Date类型的日期类型，但是传进来的值是java.util.Date，类型不符，需要转换
 43         ////定义一个java.sql.Date类型的data，new Date(date),然后将我们的值g.getBirthday().getTime()传进去
 44         //getTime() 方法可返回距 1970 年 1 月 1 日之间的毫秒数。
 45         ptmt.setDate(4, new Date(g.getBirthday().getTime()));
 46         ptmt.setString(5, g.getEmail());
 47         ptmt.setString(6, g.getMobile());
 48         ptmt.setString(7, g.getCreate_user());
 49         ptmt.setString(8, g.getUpdate_user());
 50         ptmt.setInt(9, g.getIsdel());
 51         //5、调用execute方法的时候才真正执行
 52         ptmt.execute();
 53     }
 54     //修改女神
 55     public void updateGoddess(Goddess g) throws SQLException{//参数通过对象的形式Goddess g传进来
 56         Connection conn=DBUtil.getConnection();
 57         //sql语句之间加上空格，因为等到执行的时候会变成一行，如果不加空格的话，前后的字符就会在一起，这样就会报sql错误
 58         String sql="" +
 59                 //更新女神表
 60                 " update imooc_goddess " +
 61                 //设置用户名···等于新的值
 62                 " set user_name=?,sex=?,age=?,birthday=?,email=?,mobile=?, " +
 63                 //更新人，更新时间，是否删除
 64                 " update_user=?,update_date=current_date(),isdel=? " +
 65                 //通过where条件更新其中一条记录，而不是更新所有记录即整个女神表
 66                 " where id=? ";
 67         PreparedStatement ptmt=conn.prepareStatement(sql);
 68         
 69         ptmt.setString(1, g.getUser_name());
 70         ptmt.setInt(2, g.getSex());
 71         ptmt.setInt(3, g.getAge());
 72         ptmt.setDate(4, new Date(g.getBirthday().getTime()));
 73         ptmt.setString(5, g.getEmail());
 74         ptmt.setString(6, g.getMobile());
 75         ptmt.setString(7, g.getUpdate_user());
 76         ptmt.setInt(8, g.getIsdel());
 77         ptmt.setInt(9, g.getId());
 78         ptmt.execute();
 79     }
 80     //删除女神
 81     public void delGoddess(Integer id) throws SQLException{//参数不用传递对象，只需要传递一个id进来就可以了
 82         Connection conn=DBUtil.getConnection();
 83         
 84         String sql="" +
 85                 " delete from imooc_goddess " +
 86                 //根据主键id来删
 87                 " where id=? ";
 88         PreparedStatement ptmt=conn.prepareStatement(sql);
 89         //需要一个参数id就可以了
 90         ptmt.setInt(1, id);
 91         ptmt.execute();
 92     }
 93     //查询女神，相当于全部查询，不管这张表里面有对少条记录我们都会查询出来，没有加过滤条件
 94     public List<Goddess> query() throws Exception{
 95         List<Goddess> result=new ArrayList<Goddess>();
 96         
 97         Connection conn=DBUtil.getConnection();
 98         StringBuilder sb=new StringBuilder();
 99         sb.append("select id,user_name,age from imooc_goddess  ");//没有加过滤条件
100         
101         PreparedStatement ptmt=conn.prepareStatement(sb.toString());
102         //执行查询，返回ResultSet对象
103         ResultSet rs=ptmt.executeQuery();
104         
105         Goddess g=null;
106         //rs.next()返回的是true，证明对象rs里面有数据
107         while(rs.next()){
108             g=new Goddess();
109             g.setId(rs.getInt("id"));
110             g.setUser_name(rs.getString("user_name"));
111             g.setAge(rs.getInt("age"));
112             result.add(g);
113         }
114         return result;
115     }
116     
117     //优化的查询方法，加一个查询参数：女神姓名
118     //查询女神，相当于全部查询，不管这张表里面有对少条记录我们都会查询出来，没有加过滤条件
119         public List<Goddess> query(String name) throws Exception{
120             List<Goddess> result=new ArrayList<Goddess>();
121             
122             Connection conn=DBUtil.getConnection();
123             StringBuilder sb=new StringBuilder();
124             sb.append("select * from imooc_goddess  ");
125             
126             sb.append(" where user_name=? ");
127             //预编译sql语句
128             PreparedStatement ptmt=conn.prepareStatement(sb.toString());
129             //把参数传入
130             ptmt.setString(1, name);
131             //将sql语句打印出来
132             System.out.println(sb.toString());
133             //执行查询
134             ResultSet rs=ptmt.executeQuery();
135             
136             Goddess g=null;
137             //rs.next()返回的是true，证明对象rs里面有数据
138             //遍历结果集
139             while(rs.next()){
140                 g=new Goddess();
141                 g.setId(rs.getInt("id"));
142                 g.setUser_name(rs.getString("user_name"));
143                 g.setAge(rs.getInt("age"));
144                 g.setSex(rs.getInt("sex"));
145                 g.setBirthday(rs.getDate("birthday"));
146                 g.setEmail(rs.getString("email"));
147                 g.setMobile(rs.getString("mobile"));
148                 g.setCreate_date(rs.getDate("create_date"));
149                 g.setCreate_user(rs.getString("create_user"));
150                 g.setUpdate_date(rs.getDate("update_date"));
151                 g.setUpdate_user(rs.getString("update_user"));
152                 g.setIsdel(rs.getInt("isdel"));
153                 
154                 result.add(g);
155             }
156             return result;
157         }
158         
159     //通过一个参数一个参数传进来
160     //查询女神，参数：姓名、手机号、邮箱，按照女神的姓名、手机号、邮箱来查询
161     public List<Goddess> query(String name,String mobile,String email) throws Exception{
162         List<Goddess> result=new ArrayList<Goddess>();
163         
164         Connection conn=DBUtil.getConnection();
165         StringBuilder sb=new StringBuilder();
166         sb.append("select * from imooc_goddess  ");//全部查询，没有过滤条件
167         //加上查询参数
168         sb.append(" where user_name like ? and mobile like ? and email like ?");
169         
170         PreparedStatement ptmt=conn.prepareStatement(sb.toString());
171         //这边的查询参数是写死的，但可以通过集合方式传进来，更加便捷
172         ptmt.setString(1, "%"+name+"%");//%通配符
173         ptmt.setString(2, "%"+mobile+"%");
174         ptmt.setString(3, "%"+email+"%");
175         System.out.println(sb.toString());
176         ResultSet rs=ptmt.executeQuery();
177         
178         Goddess g=null;
179         while(rs.next()){
180             g=new Goddess();
181             g.setId(rs.getInt("id"));
182             g.setUser_name(rs.getString("user_name"));
183             g.setAge(rs.getInt("age"));
184             g.setSex(rs.getInt("sex"));
185             g.setBirthday(rs.getDate("birthday"));
186             g.setEmail(rs.getString("email"));
187             g.setMobile(rs.getString("mobile"));
188             g.setCreate_date(rs.getDate("create_date"));
189             g.setCreate_user(rs.getString("create_user"));
190             g.setUpdate_date(rs.getDate("update_date"));
191             g.setUpdate_user(rs.getString("update_user"));
192             g.setIsdel(rs.getInt("isdel"));
193             //循环放到集合里面，返回集合
194             result.add(g);
195         }
196         return result;
197     }
198     //不通过一个参数一个参数传进来，传递一个集合，通过集合的方式List ，把这些参数放到集合里面，然后再传进来，查询的条件也可以通过集合方式Map<String, Object>传进来，这种方式更便捷
199     //查询参数通过集合传过来params
200     public List<Goddess> query(List<Map<String, Object>> params) throws Exception{
201         List<Goddess> result=new ArrayList<Goddess>();
202         
203         Connection conn=DBUtil.getConnection();
204         StringBuilder sb=new StringBuilder();
205         //1=1永远成立，后面再追加and就没问题了,where后面不能直接加and
206         sb.append("select * from imooc_goddess where 1=1 ");
207         //判断集合是否为空
208         if(params!=null&&params.size()>0){
209             //遍历集合
210             for (int i = 0; i < params.size(); i++) {
211                 Map<String, Object> map=params.get(i);
212                 //拼装sql语句，查询变量name，查询关系rela（例：=），变量的值value
213                 //就不会像sb.append(" where user_name like ? and mobile like ? and email like ?");把查询条件写死
214                 //这里可以改变查询参数
215                 //如果把and去掉，第一条参数可以，第二条就没有and来连接了，所以可以在前面的sql语句加上where 1=1
216                 //name:要查询的字段，rela：查询的关系（=,>,<,like），value:要传输查询参数的值
217                 sb.append("  and "+map.get("name")+" "+map.get("rela")+" "+map.get("value")+" ");
218                 
219             }
220         }
221         
222         PreparedStatement ptmt=conn.prepareStatement(sb.toString());
223         
224         System.out.println(sb.toString());//打印sql语句
225         ResultSet rs=ptmt.executeQuery();
226         
227         Goddess g=null;
228         while(rs.next()){
229             g=new Goddess();
230             g.setId(rs.getInt("id"));
231             g.setUser_name(rs.getString("user_name"));
232             g.setAge(rs.getInt("age"));
233             g.setSex(rs.getInt("sex"));
234             g.setBirthday(rs.getDate("birthday"));
235             g.setEmail(rs.getString("email"));
236             g.setMobile(rs.getString("mobile"));
237             g.setCreate_date(rs.getDate("create_date"));
238             g.setCreate_user(rs.getString("create_user"));
239             g.setUpdate_date(rs.getDate("update_date"));
240             g.setUpdate_user(rs.getString("update_user"));
241             g.setIsdel(rs.getInt("isdel"));
242             
243             result.add(g);
244         }
245         return result;
246     }
247     //查询一个女神，得到其中一个女神的详细信息
248     public Goddess get(Integer id) throws SQLException{//根据id来查
249         Goddess g=null;
250         Connection conn=DBUtil.getConnection();
251         String sql="" +
252                 " select * from imooc_goddess " +
253                 " where id=? ";
254         //预编译sql语句
255         PreparedStatement ptmt=conn.prepareStatement(sql);
256         //传入参数
257         ptmt.setInt(1, id);
258         //execute()方法用来执行更改数据库的操作，包括新增、修改、删除。
259         //executeQuery()方法：查询
260         ResultSet rs=ptmt.executeQuery();//执行查询，返回结果集rs
261         //遍历结果集
262         while(rs.next()){
263             g=new Goddess();
264             g.setId(rs.getInt("id"));
265             g.setUser_name(rs.getString("user_name"));
266             g.setAge(rs.getInt("age"));
267             g.setSex(rs.getInt("sex"));
268             //g.setBirthday:java.util.Date
269             //rs.getDate:java.sql.Date
270             //注意：这里的java.sql.Date不需要转成java.util.Date，因为java.sql.Date是java.util.Date的子集
271             g.setBirthday(rs.getDate("birthday"));
272             g.setEmail(rs.getString("email"));
273             g.setMobile(rs.getString("mobile"));
274             g.setCreate_date(rs.getDate("create_date"));
275             g.setCreate_user(rs.getString("create_user"));
276             g.setUpdate_date(rs.getDate("update_date"));
277             g.setUpdate_user(rs.getString("update_user"));
278             g.setIsdel(rs.getInt("isdel"));
279         }
280         return g;//返回女神对象
281     }
282 }

控制层

  1 package com.imooc.action;
  2 //控制层
  3 import java.sql.SQLException;
  4 import java.util.ArrayList;
  5 import java.util.Date;
  6 import java.util.HashMap;
  7 import java.util.List;
  8 import java.util.Map;
  9 
 10 import com.imooc.dao.GoddessDao;
 11 import com.imooc.model.Goddess;
 12 
 13 public class GoddessAction {
 14 
 15     public void add(Goddess goddess) throws Exception{
 16         GoddessDao dao=new GoddessDao();
 17         goddess.setSex(1);
 18         goddess.setCreate_user("ADMIN");
 19         goddess.setUpdate_user("ADMIN");
 20         goddess.setIsdel(0);
 21         dao.addGoddess(goddess);
 22     }
 23     
 24     public Goddess get(Integer id) throws SQLException{
 25         GoddessDao dao=new GoddessDao();
 26         return dao.get(id);
 27     }
 28     
 29     public void edit(Goddess goddess) throws Exception{
 30         GoddessDao dao=new GoddessDao();
 31         dao.updateGoddess(goddess);
 32     }
 33     public void del(Integer id) throws SQLException{
 34         GoddessDao dao=new GoddessDao();
 35         dao.delGoddess(id);
 36     }
 37     
 38     public List<Goddess>  query() throws Exception{
 39         GoddessDao dao=new GoddessDao();
 40         return dao.query();
 41     }
 42     public List<Goddess> query(List<Map<String, Object>> params) throws Exception{
 43         GoddessDao dao=new GoddessDao();
 44         return dao.query(params);
 45     }
 46     
 47     public static void main(String[] args) throws Exception {
 48         
 49 //        //1、测试新增女神功能
 50 //        GoddessDao g=new GoddessDao();
 51 //        
 52 //        //定义女神对象
 53 //        Goddess g1=new Goddess();
 54 //        
 55 //        g1.setUser_name("小夏");
 56 //        g1.setAge(22);
 57 //        g1.setSex(1);
 58 //        g1.setBirthday(new Date());
 59 //        g1.setEmail("xiaxia@imooc.com");
 60 //        g1.setMobile("18766888866");
 61 //        g1.setCreate_user("ADMIN");
 62 //        g1.setUpdate_user("ADMIN");
 63 //        g1.setIsdel(1);
 64 //        
 65 //        g.addGoddess(g1);
 66 /**************************************************************************/        
 67 //        //1-1、测试新增女神功能
 68 //        GoddessDao g=new GoddessDao();
 69 //        
 70 //        //定义女神对象
 71 //        Goddess g1=new Goddess();
 72 //        
 73 //        g1.setUser_name("小美");
 74 //        g1.setAge(22);
 75 //        g1.setSex(1);
 76 //        g1.setBirthday(new Date());
 77 //        g1.setEmail("xiaxia@imooc.com");
 78 //        g1.setMobile("18766888866");
 79 //        g1.setCreate_user("ADMIN");
 80 //        g1.setUpdate_user("ADMIN");
 81 //        g1.setIsdel(1);
 82 //        
 83 //        g.addGoddess(g1);
 84 /**************************************************************************/        
 85 //        //2、测试更新女神功能
 86 //        GoddessDao g=new GoddessDao();
 87 //        
 88 //        //定义女神对象
 89 //        Goddess g1=new Goddess();
 90 //        
 91 //        g1.setUser_name("小夏");
 92 //        g1.setAge(21);
 93 //        g1.setSex(1);
 94 //        g1.setBirthday(new Date());
 95 //        g1.setEmail("xiaxia@imooc.com");
 96 //        g1.setMobile("18712345678");
 97 //        g1.setUpdate_user("ADMIN");
 98 //        g1.setIsdel(1);
 99 //        
100 //        g1.setId(7);
101 //        
102 //        g.updateGoddess(g1);
103     
104 /**************************************************************************/    
105 //        //3、测试删除女神功能
106 //        GoddessDao g=new GoddessDao();
107 //        
108 //        //定义女神对象
109 //        Goddess g1=new Goddess();
110 //        
111 //        g1.setUser_name("小夏");
112 //        g1.setAge(21);
113 //        g1.setSex(1);
114 //        g1.setBirthday(new Date());
115 //        g1.setEmail("xiaxia@imooc.com");
116 //        g1.setMobile("18712345678");
117 //        g1.setUpdate_user("ADMIN");
118 //        g1.setIsdel(1);
119 //        
120 //        g1.setId(7);
121 //        
122 //        g.delGoddess(7);
123         
124 /**************************************************************************/    
125 //        //4、测试查询单个女神的信息
126 //        GoddessDao g=new GoddessDao();
127 //        
128 //        //定义女神对象
129 //        Goddess g1=new Goddess();
130 //        
131 //        g1.setUser_name("小夏");
132 //        g1.setAge(21);
133 //        g1.setSex(1);
134 //        g1.setBirthday(new Date());
135 //        g1.setEmail("xiaxia@imooc.com");
136 //        g1.setMobile("18712345678");
137 //        g1.setUpdate_user("ADMIN");
138 //        g1.setIsdel(1);
139 //        
140 //        g1.setId(7);
141 //        
142 //        //返回一个女神对象
143 //        Goddess g2=g.get(9);
144 //        //把查询到的女神信息打印到控制台
145 //        System.out.println(g2.toString());
146         
147 /**************************************************************************/    
148 //        //5、测试查询女神的信息
149 //        GoddessDao g=new GoddessDao();
150 //        //查询小美的信息
151 //        List<Goddess> result=g.query("小夏");
152 //        //遍历结果集
153 //        for (int i = 0; i < result.size(); i++) {
154 //            //将信息打印到控制台上面
155 //            System.out.println(result.get(i).toString());
156 //        }
157 //        //定义女神对象
158 //        Goddess g1=new Goddess();
159 //        
160 //        g1.setUser_name("小美");
161 //        g1.setAge(22);
162 //        g1.setSex(1);
163 //        g1.setBirthday(new Date());
164 //        g1.setEmail("xiaxia@imooc.com");
165 //        g1.setMobile("18766888866");
166 //        g1.setCreate_user("ADMIN");
167 //        g1.setUpdate_user("ADMIN");
168 //        g1.setIsdel(1);
169         
170 /**************************************************************************/    
171         //6、测试通过集合方式查询女神的信息
172         GoddessDao g=new GoddessDao();
173         
174         List<Map<String, Object>> params=new ArrayList<Map<String,Object>>();
175         Map<String,Object> param=new HashMap<String,Object>();
176         param.put("name", "user_name");
177 //        param.put("rela", "=");
178 //        param.put("value", "'小夏'");
179         
180         param.put("rela", "like");
181         param.put("value", "'%小美%'");
182         //把参数放到集合里面去
183         params.add(param);//这一句一定要加，否则会被后面的覆盖
184 /**************************************************************************/    
185         //加入查询条件：按手机号查询
186         param=new HashMap<String,Object>();
187         param.put("name", "mobile");
188 //        param.put("rela", "=");
189 //        param.put("value", "'18712345678'");
190         
191         param.put("rela", "like");
192         param.put("value", "'%18712345678%'");
193         //把参数放到集合里面去
194         params.add(param);
195 /**************************************************************************/        
196         param=new HashMap<String,Object>();
197         param.put("name", "email");
198         param.put("rela", "=");
199         param.put("value", "'xiaxia@imooc.com'");
200         //把参数放到集合里面去
201         params.add(param);
202 /**************************************************************************/            
203         
204         
205         List<Goddess> result=g.query(params);
206         //遍历结果集
207         for (int i = 0; i < result.size(); i++) {
208             //将信息打印到控制台上面
209             System.out.println(result.get(i).toString());
210         }
211 //               定义女神对象
212         Goddess g1=new Goddess();
213         
214         g1.setUser_name("小美");
215         g1.setAge(22);
216         g1.setSex(1);
217         g1.setBirthday(new Date());
218         g1.setEmail("xiaxia@imooc.com");
219         g1.setMobile("18766888866");
220         g1.setCreate_user("ADMIN");
221         g1.setUpdate_user("ADMIN");
222         g1.setIsdel(1);
223     }
224         
225 }
226

视图层

  1 package com.imooc.view;
  2 
  3 import java.text.ParseException;
  4 import java.text.SimpleDateFormat;
  5 import java.util.Date;
  6 import java.util.List;
  7 import java.util.Scanner;
  8 
  9 import com.imooc.action.GoddessAction;
 10 import com.imooc.model.Goddess;
 11 
 12 public class View {
 13     //提示语
 14     private static final String CONTEXT="欢迎来到女神禁区：\n" +
 15             "下面是女神禁区的功能列表：\n" +
 16             "[MAIN/M]:主菜单\n" +
 17             "[QUERY/Q]:查看全部女神的信息\n" +
 18             "[GET/G]:查看某位女神的详细信息\n" +
 19             "[ADD/A]:添加女神信息\n" +
 20             "[UPDATE/U]:更新女神信息\n" +
 21             "[DELETE/D]:删除女神信息\n" +
 22             "[SEARCH/S]:查询女神信息(根据姓名、手机号来查询)\n" +
 23             "[EXIT/E]:退出女神禁区\n" +
 24             "[BREAK/B]:退出当前功能，返回主菜单";
 25     //操作标记
 26     private static final String OPERATION_MAIN="MAIN";//访问主菜单（功能列表）
 27     private static final String OPERATION_QUERY="QUERY";
 28     private static final String OPERATION_GET="GET";
 29     private static final String OPERATION_ADD="ADD";
 30     private static final String OPERATION_UPDATE="UPDATE";
 31     private static final String OPERATION_DELETE="DELETE";
 32     private static final String OPERATION_SEARCH="SEARCH";
 33     private static final String OPERATION_EXIT="EXIT";
 34     private static final String OPERATION_BREAK="BREAK";
 35 
 36     public static void main(String[] args) {
 37         
 38         System.out.println(CONTEXT);
 39         //怎么保持程序一直运行，永真循环 while(true){}
 40         
 41         //接收控制台输入参数
 42         Scanner scan=new Scanner(System.in);
 43         Goddess goddess=new Goddess();
 44         GoddessAction action=new GoddessAction();
 45         String prenious=null;//记忆变量，记忆上一次请求的是哪一个分支哪一个模块
 46         Integer step=1;//标记步骤
 47         while(scan.hasNext()){//有输入值的时候才循环
 48             String in=scan.next().toString();
 49             if(OPERATION_EXIT.equals(in.toUpperCase())
 50                     //OPERATION_EXIT.substring(0, 1)截取E,toUpperCase()转换成大写
 51                     ||OPERATION_EXIT.substring(0, 1).equals(in.toUpperCase())){
 52                 System.out.println("您已成功退出女神禁区。");
 53                 break;
 54             }else if(OPERATION_QUERY.equals(in.toUpperCase())
 55                     ||OPERATION_QUERY.substring(0, 1).equals(in.toUpperCase())){
 56                 try {
 57                     List<Goddess> list=action.query();
 58                     for (Goddess go : list) {
 59                         System.out.println(go.getId()+",姓名："+go.getUser_name());
 60                     }
 61                 } catch (Exception e) {
 62                     // TODO Auto-generated catch block
 63                     e.printStackTrace();
 64                 }
 65                 
 66                 
 67             }else if(OPERATION_ADD.equals(in.toUpperCase())
 68                     ||OPERATION_ADD.substring(0, 1).equals(in.toUpperCase())
 69                     ||OPERATION_ADD.equals(prenious)){
 70                 prenious=OPERATION_ADD;
 71                 //新增女神
 72                 
 73                 if(1==step){
 74                     System.out.println("请输入女神的［姓名］");
 75                 }else if(2==step){
 76                     goddess.setUser_name(in);
 77                     System.out.println("请输入女神的［年龄］");
 78                 }else if(3==step){
 79                     goddess.setAge(Integer.valueOf(in));
 80                     System.out.println("请输入女神的［生日］，格式如：yyyy-MM-dd");
 81                 }else if(4==step){
 82                     SimpleDateFormat sf=new SimpleDateFormat("yyyy-MM-dd");
 83                     Date birthday=null;
 84                     try {
 85                         birthday = sf.parse(in);
 86                         goddess.setBirthday(birthday);
 87                         System.out.println("请输入女神的［邮箱］");
 88                     } catch (ParseException e) {
 89                         e.printStackTrace();
 90                         System.out.println("您输入的格式有误，请重新输入");
 91                         step=3;
 92                     }
 93                 }else if(5==step){
 94                     goddess.setEmail(in);
 95                     System.out.println("请输入女神的［手机号］");
 96                 }else if(6==step){
 97                     goddess.setMobile(in);
 98                     
 99                     try {
100                         action.add(goddess);
101                         System.out.println("新增女神成功");
102                     } catch (Exception e) {
103                         e.printStackTrace();
104                         System.out.println("新增女神失败");
105                     }
106                 }
107                 if(OPERATION_ADD.equals(prenious)){
108                     step++;                    
109                 }
110             }else{
111                 System.out.println("您输入的值为:"+in);                
112             }
113             
114         }
115     }
116 }

数据库

 1 package com.imooc.db;
 2 
 3 import java.sql.Connection;
 4 import java.sql.DriverManager;
 5 import java.sql.SQLException;
 6 //获得数据库连接
 7 public class DBUtil {
 8 
 9     private static final String URL="jdbc:mysql://127.0.0.1:3306/imooc?useUnicode=true&characterEncoding=utf-8";
10     private static final String USER="root";
11     private static final String PASSWORD="123456";
12     
13     private static Connection conn=null;
14     
15     static {
16         try {
17             //1.加载驱动程序
18             Class.forName("com.mysql.jdbc.Driver");
19             //2.获得数据库的连接
20             conn=DriverManager.getConnection(URL, USER, PASSWORD);
21         } catch (ClassNotFoundException e) {
22             e.printStackTrace();
23         } catch (SQLException e) {
24             e.printStackTrace();
25         }
26     }
27     //对外提供一个方法来获得数据库连接
28     public static Connection getConnection(){
29         return conn;
30     }
31 
32 }

posted on 2018-10-15 17:14 songsong_p_blue 阅读(372) 评论(0) 编辑收藏举报