Java中使用 DAO分层设计练习及Maven的配置使用（软件工程综合实践课程第五周作业）

已于 2022-12-15 21:31:49 修改
阅读量1k 收藏 7
点赞数 4
分类专栏： 软件工程综合实践 文章标签： maven java 开发语言 mysql intellij-idea
于 2022-09-26 22:50:34 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/GCTTTTTT/article/details/127061719
版权

文章目录

一、实验要求

要求：

  • 配置好maven；
  • 创建一个maven项目，将mysql-connector-java-8.0.13.jar配置到pom.xml文件 中；
  • 参考TestDao.java程序，自行设计一个程序，访问myschool数据库的course表；
  • 将运行结果截图，和程序一起提交。

二、具体流程

1、安装和配置Maven

首先要先安装和配置好maven和maven仓库之类的，根据Maven_实验指导.pdf里面步骤一步步安装和配置就行

2、创建一个maven项目

File—New—Project新建一个项目：
在这里插入图片描述
选中maven：
在这里插入图片描述
next后在Name和Location处配置项目名字和位置（Artifact Coordinates可以直接用默认的）然后点finish就好了：
在这里插入图片描述

3、配置pom.xml文件

我们可以看到正常新建完maven项目后大致是这样的
在这里插入图片描述
打开pom.xml文件开始配置
在这里插入图片描述
这里要注意配置的mysql驱动版本跟自己的mysql版本最好一致，要求里的是8.0.13版本，但我之前用的是8.0.17的mysql所以我驱动也用的8.0.17

关于mysql版本的查看：
cmd中输入mysql --version：
在这里插入图片描述

关于maven依赖的相关信息查询：
这是maven官方的仓库查询地址：https://mvnrepository.com/
在输入框里输入想要查找的依赖点击search：
在这里插入图片描述
找到所需要的依赖：
在这里插入图片描述
在里面找到所需要的版本点击进入（我的是8.0.17）：
在这里插入图片描述
就能找到maven中该依赖的写法啦
在这里插入图片描述

也可以直接复制这个↓，不过要根据自己的版本改一下版本号

<dependencies>
        <!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
        <dependency>
<!--            我本地的mysql版本装的是8.0.17，所以导入对应版本的驱动-->
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.17</version>
        </dependency>

    </dependencies>

要注意官网中复制的话是<dependency> </dependency>标签里面的，但在pom.xml里面<dependency> </dependency>标签外面还有一层<dependencies> </dependencies>！！！

最终的pom.xml文件长这样：
在这里插入图片描述
别忘了要点一下右上角的这个来更新一下：
在这里插入图片描述
pom.xml配置好后可以在右边这个栏里看看依赖有没有成功导入：
在这里插入图片描述
然后就可以开始写代码了！

4、项目结构

在这里插入图片描述

5、参考代码

关于database.properties配置文件先说一下

  • mysql8中driver是com.mysql.cj.jdbc.Driver
  • mysql8中的url建议写成：jdbc:mysql://服务器ip:端口/数据库名?characterEncoding=utf8&useSSL=false&serverTimezone=UTC&rewriteBatchedStatements=true
    比如这个项目里面在本地服务器3306端口的话就是jdbc:mysql://localhost:3306/myschool?characterEncoding=utf8&useSSL=false&serverTimezone=UTC&rewriteBatchedStatements=true 用老师的那个的话可能会报错
  • 密码是自己的数据库登录的时候的那个密码
  • com.java.DB.DBUtilConfig中这一句注意路径就直接是database.properties
    在这里插入图片描述
    看的是编译后的路径，也就是target文件夹中的路径在这里插入图片描述
    具体原因可以参考：Maven获取resources的文件路径、读取resources的文件

com.java.Dao包

com.java.Dao.CourseDao
package com.java.Dao;

import com.java.Entity.Course;

import java.util.List;

public interface CourseDao {
    public boolean add(Course item);

    public boolean deleteById(int id);

    public boolean update(Course item);

    public List<Course> findAll();

    public List<Course> findById(int id);

}
com.java.Dao.UserDao
package com.java.Dao;

import com.java.Entity.User;

import java.util.List;

//专门处理user表的接口
public interface UserDao {

    public boolean add(User item);

    public boolean deleteById(int id);

    public boolean update(User item);

    public List<User> findAll();

    public List<User> findById(int id);

}
com.java.Dao.Impl包
com.java.Dao.Impl.CourseDaoImpl
package com.java.Dao.Impl;

import com.java.DB.DBUtilConfig;
import com.java.Dao.CourseDao;
import com.java.Entity.Course;

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

/**
 * @projectName:  
 * @package: com.java.Dao.Impl
 * @className: CourseDaoImpl
 * @author: GCT
 * @description: TODO
 * @date: 2022/9/26 18:45
 * @version: 1.0
 */
public class CourseDaoImpl implements CourseDao {
    private DBUtilConfig db;

    public CourseDaoImpl() {
        db=new DBUtilConfig();
    }

    @Override
    public boolean add(Course item) {
//        String sql="insert into course(cname,credit,department,content) values('"+item.getCname()+"','"+item.getCredit()+"','"+item.getDepartment()+"','"+item.getContent()+"')";
        String sql="insert into course(id,cname,credit,department,content) values(null,?,?,?,?)";
        Object[] params = { item.getCname(),item.getCredit(),item.getDepartment(),item.getContent() };
        return db.execUpdate(sql,params);
    }

    @Override
    public boolean deleteById(int id) {
        String sql="delete from course where id = ?";
        Object[] params = { id };
        return db.execUpdate(sql,params);

    }

    @Override
    public boolean update(Course item) {
        String sql="update course set cname= ?,credit = ?,department = ?,content = ? where id = ?";
        Object[] params = { item.getCname(),item.getCredit(),item.getDepartment(),item.getContent(),item.getId() };
        return db.execUpdate(sql,params);
    }

    @Override
    public List<Course> findById(int id) {
        List<Course> courseList = new ArrayList<Course>();
        String selectCourse="select * from course where id = ?";
//        封装参数
        Object[] selparams = { id };
        //2.执行并接收查询结果
        ResultSet rest= db.execQueryById(selectCourse,selparams);
        try {
            while(rest.next())
            {
                int iid=rest.getInt("id");
                String cname=rest.getString("cname");
                int credit=rest.getInt("credit");
                String department=rest.getString("department");
                String content=rest.getString("content");
                courseList.add(new Course(iid,cname,credit,department,content));
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
        finally
        {
            db.DBclose();
        }
        return courseList;
    }

    @Override
    public List<Course> findAll() {
        List<Course> courseList = new ArrayList<Course>();
        String selectCourse="select * from course";
//        封装参数
//        Object[] selparams = { 1 };
        //2.执行并接收查询结果
        ResultSet rest= db.execQueryAll(selectCourse);
        try {
            while(rest.next())
            {
                int id=rest.getInt("id");
                String cname=rest.getString("cname");
                int credit=rest.getInt("credit");
                String department=rest.getString("department");
                String content=rest.getString("content");
                courseList.add(new Course(id,cname,credit,department,content));
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
        finally
        {
            db.DBclose();
        }
        return courseList;
    }
}
com.java.Dao.Impl.UserDaoImpl
package com.java.Dao.Impl;

import com.java.DB.DBUtilConfig;
import com.java.Dao.UserDao;
import com.java.Entity.User;

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

//UserDao的实现类，通过DBUtil访问数据库
public class UserDaoImpl implements UserDao {
    private DBUtilConfig db;

    public UserDaoImpl() {
        db=new DBUtilConfig();
    }

    @Override
    public boolean add(User item) {
//        String sql="insert into course(cname,credit,department,content) values('"+item.getCname()+"','"+item.getCredit()+"','"+item.getDepartment()+"','"+item.getContent()+"')";
        String sql="insert into users(id,username,password) values(null,?,?)";
        Object[] params = { item.getUsername(),item.getPassword() };
        return db.execUpdate(sql,params);
    }

    @Override
    public boolean deleteById(int id) {
        String sql="delete from users where id = ?";
        Object[] params = { id };
        return db.execUpdate(sql,params);

    }

    @Override
    public boolean update(User item) {
        String sql="update users set username= ?,password = ? where id = ?";
        Object[] params = { item.getUsername(),item.getPassword(),item.getId() };
        return db.execUpdate(sql,params);
    }

    @Override
    public List<User> findById(int id) {
        List<User> usersList = new ArrayList<User>();
        String selectUsers="select * from users where id = ?";
//        封装参数
        Object[] selparams = { id };
        //2.执行并接收查询结果
        ResultSet rest= db.execQueryById(selectUsers,selparams);
        try {
            while(rest.next())
            {
                int iid=rest.getInt("id");
                String username=rest.getString("username");
                String password=rest.getString("password");
                usersList.add(new User(iid,username,password));
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
        finally
        {
            db.DBclose();
        }
        return usersList;
    }

    @Override
    public List<User> findAll() {
        List<User> usersList = new ArrayList<User>();
        String selectUsers="select * from users";
//        封装参数
//        Object[] selparams = { 1 };
        //2.执行并接收查询结果
        ResultSet rest= db.execQueryAll(selectUsers);
        try {
            while(rest.next())
            {
                int iid=rest.getInt("id");
                String username=rest.getString("username");
                String password=rest.getString("password");
                usersList.add(new User(iid,username,password));
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
        finally
        {
            db.DBclose();
        }
        return usersList;
    }
}

com.java.DB包

com.java.DB.DBUtilConfig
package com.java.DB;

import java.io.InputStream;
import java.sql.*;
import java.util.Properties;

//DBUtilConfig读取配置文件

public class DBUtilConfig {

    private static String driver = null;
    private static String url = null;
    private static String username = null;
    private static String password = null;
    protected Connection conn;

    //静态代码块,在类初次被加载的时候执行且仅会被执行一次
    static {
        try {
            // 在Java中，其配置文件常为.properties文件，是以键值对的形式进行参数配置的。
            // 用Properties类来读取.properties文件数据

            // 步骤说明：1.调用类加载器的方法加载资源，返回的字节流
            // DBUtilConfig.class是获得当前对象所属的class对象
            // getClassLoader()是取得该Class对象的类装载器
            // getResourceAsStream(“database.properties”)
            InputStream ins = DBUtilConfig.class.getClassLoader().getResourceAsStream("database.properties");

            // 2.使用Properties类，从.properties属性文件对应的文件输入流中，加载属性列表到Properties类对象，
            Properties props = new Properties();
            props.load(ins);

            // 3.通过getProperty方法用指定的键在此属性列表中搜索属性， 动态获取.properties配置文件中的数据
            driver = props.getProperty("driver");
            url = props.getProperty("url");
            username = props.getProperty("username");
            password = props.getProperty("password");

            // 4、加载驱动
            Class.forName(driver);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static Connection getConnection() throws SQLException {
        return DriverManager.getConnection(url, username, password);
    }

    // 3.执行更新数据库的预编译SQL命令
    public boolean execUpdate(String sql, Object[] params) {
        try {
            conn = getConnection();
        } catch (SQLException e1) {
            e1.printStackTrace();
        }
        try {

            // 1.创建预编译命令对象
            PreparedStatement stmt = conn.prepareStatement(sql);
            // 2.设置为字段匹配参数
            for (int i = 0; params != null && i < params.length; i++) {

                Object param = params[i];
                if (param instanceof Integer) {
                    stmt.setInt(i + 1, Integer.parseInt(param.toString()));
                }
                if (param instanceof Float) {
                    stmt.setFloat(i + 1, Float.parseFloat(param.toString()));
                }
                if (param instanceof Double) {
                    stmt.setDouble(i + 1, Double.parseDouble(param.toString()));
                }
                if (param instanceof String) {
                    stmt.setString(i + 1, param.toString());
                }
            }

            // 3.执行预编译命令
            if (stmt.executeUpdate() > 0) {
                return true;
            }

        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            if (conn != null) {
                try {
                    conn.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
        }
        return false;
    }

    // 4.执行预编译查询
    public ResultSet execQueryById(String sql, Object[] params) {
        try {
            conn = getConnection();
        } catch (SQLException e1) {
            e1.printStackTrace();
        }

        try {
            // 1.创建预编译命令对象
            PreparedStatement stmt = conn.prepareStatement(sql);
            // 2.设置为字段匹配参数
            for (int i = 0; params != null && i < params.length; i++) {

                Object param = params[i];
                if (param instanceof Integer) {
                    stmt.setInt(i + 1, Integer.parseInt(param.toString()));
                }
                if (param instanceof Float) {
                    stmt.setFloat(i + 1, Float.parseFloat(param.toString()));
                }
                if (param instanceof Double) {
                    stmt.setDouble(i + 1, Double.parseDouble(param.toString()));
                }
                if (param instanceof String) {
                    stmt.setString(i + 1, param.toString());
                }
            }

            // 3.执行预编译命令
            return stmt.executeQuery();

        } catch (SQLException e) {
            e.printStackTrace();
        }
        return null;
    }

    // 4.执行查询全部
    public ResultSet execQueryAll(String sql) {
        try {
            conn = getConnection();
        } catch (SQLException e) {
            e.printStackTrace();
        }
        try {
            Statement stmt = conn.createStatement();
//            PreparedStatement stmt = conn.prepareStatement(sql);
            return stmt.executeQuery(sql);
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return null;
    }

    // 5.关闭数据库
    public void DBclose() {
        if (conn != null) {
            try {
                conn.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }

    }
}

com.java.Entity包

com.java.Entity.Course
package com.java.Entity;

/**
 * @projectName:  
 * @package: com.java.Entity
 * @className: Course
 * @author: GCT
 * @description: TODO
 * @date: 2022/9/26 19:48
 * @version: 1.0
 */
public class Course {
    private int id;

    private String cname;

    private int credit;

    private String department;

    private String content;

    public Course() {

    }

    public Course(String cname, int credit, String department, String content) {
        this.cname = cname;
        this.credit = credit;
        this.department = department;
        this.content = content;
    }

    public Course(int id, String cname, int credit, String department, String content) {
        this.id = id;
        this.cname = cname;
        this.credit = credit;
        this.department = department;
        this.content = content;
    }

    public int getId() {
        return id;
    }

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

    public String getCname() {
        return cname;
    }

    public void setCname(String cname) {
        this.cname = cname;
    }

    public int getCredit() {
        return credit;
    }

    public void setCredit(int credit) {
        this.credit = credit;
    }

    public String getDepartment() {
        return department;
    }

    public void setDepartment(String department) {
        this.department = department;
    }

    public String getContent() {
        return content;
    }

    public void setContent(String content) {
        this.content = content;
    }

    @Override
    public String toString() {
        return "Course{" +
                "id=" + id +
                ", cname='" + cname + '\'' +
                ", credit=" + credit +
                ", department='" + department + '\'' +
                ", content='" + content + '\'' +
                '}';
    }
}
com.java.Entity.User
package com.java.Entity;

// User实体类，针对数据表User,实现数据表到类结构的转换，供 DAO层使用
public class User {
    private int id;// 主键

    private String username;// 用户名

    private String password;// 密码


    public User(int id, String username, String password) {
        super();
        this.id = id;
        this.username = username;
        this.password = password;
    }

    public User(String username, String password) {
        super();
        this.username = username;
        this.password = password;
    }


    public User() {
        super();
        // TODO Auto-generated constructor stub
    }

    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;
    }



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

src/main/resources包

src/main/resources/database.properties
#mysql8
driver=com.mysql.cj.jdbc.Driver
url=jdbc:mysql://localhost:3306/myschool?characterEncoding=utf8&useSSL=false&serverTimezone=UTC&rewriteBatchedStatements=true
username=root
#password=root
password=你的密码

src/test包

src/test/java/TestMavenCourseDao.java
import com.java.Dao.CourseDao;
import com.java.Dao.Impl.CourseDaoImpl;
import com.java.Entity.Course;

import java.util.List;

/**
 * @projectName: 
 * @package: PACKAGE_NAME
 * @className: TestMavenCourseDao
 * @author: GCT
 * @description: TODO
 * @date: 2022/9/26 18:46
 * @version: 1.0
 */
public class TestMavenCourseDao {

    public static void main(String[] args) {
        CourseDao courseDao = new CourseDaoImpl();
//        ===============测试插入语句===============
        courseDao.add(new Course("test",3,"test","test"));

//        ===============测试查询语句===============
//        根据传入的Id值返回表中对应id的行内容
        System.out.println("=============findById==============");
        List<Course> courseListById = courseDao.findById(2);
        for (Course item:courseListById){
            System.out.println(item.toString());
        }

        System.out.println("=============findAll()==============");
        List<Course> courseListAll1 = courseDao.findAll();
        for (Course item:courseListAll1){
            System.out.println(item.toString());
        }
//        ===============测试删除语句===============
        courseDao.deleteById(8);
        System.out.println("=============deleteById后findAll()==============");
        List<Course> courseListAll2 = courseDao.findAll();
        for (Course item:courseListAll2){
            System.out.println(item.toString());
        }
//        ===============测试更新语句===============
        courseDao.update(new Course(10,"test_update",6666,"test_update","test_update"));
        System.out.println("=============update后findAll()==============");
        List<Course> courseListAll3 = courseDao.findAll();
        for (Course item:courseListAll3){
            System.out.println(item.toString());
        }



    }
}
src/test/java/TestMavenUserDao.java
import com.java.Dao.CourseDao;
import com.java.Dao.Impl.CourseDaoImpl;
import com.java.Dao.Impl.UserDaoImpl;
import com.java.Dao.UserDao;
import com.java.Entity.Course;
import com.java.Entity.User;

import java.util.List;

/**
 * @projectName:  
 * @package: PACKAGE_NAME
 * @className: TestMavenUserDao
 * @author: GCT
 * @description: TODO
 * @date: 2022/9/26 21:27
 * @version: 1.0
 */
public class TestMavenUserDao {
    public static void main(String[] args) {
        UserDao userDao = new UserDaoImpl();
//        ===============测试插入语句===============
        userDao.add(new User("test","test"));

//        ===============测试查询语句===============
//        根据传入的Id值返回表中对应id的行内容
        System.out.println("=============findById==============");
        List<User> userListById = userDao.findById(2);
        for (User item:userListById){
            System.out.println(item.toString());
        }

        System.out.println("=============findAll()==============");
        List<User> userListAll1 = userDao.findAll();
        for (User item:userListAll1){
            System.out.println(item.toString());
        }
//        ===============测试删除语句===============
        userDao.deleteById(10);
        System.out.println("=============deleteById后findAll()==============");
        List<User> userListAll2 = userDao.findAll();
        for (User item:userListAll2){
            System.out.println(item.toString());
        }
//        ===============测试更新语句===============
        userDao.update(new User(3,"test6666","test6666"));
        System.out.println("=============update后findAll()==============");
        List<User> userListAll3 = userDao.findAll();
        for (User item:userListAll3){
            System.out.println(item.toString());
        }
    }

}

pom.xml

注意项目名和mysql驱动的版本要根据自己的项目修改

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>org.example</groupId>
    <artifactId>项目名</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>

    <dependencies>
        <!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
        <dependency>
<!--            我本地的mysql版本装的是8.0.17，所以导入对应版本的驱动-->
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.17</version>
        </dependency>
    </dependencies>
</project>

6、运行结果

TestMavenCourseDao.java

在这里插入图片描述
在这里插入图片描述

TestMavenUserDao.java

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

7、数据库表结构

本项目中数据库表的创建：在可视化工具中运行资料中的myschool.sql就ok了
比如navicat中：
在这里插入图片描述
找到myschool.sql文件并运行就行了

基本结构：
在这里插入图片描述
在这里插入图片描述

GCTTTTTT
关注
  • 4
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 4
    评论
专栏目录
Java项目 常用包的命名及理解【dao包、domain包、service包、utils包、web包、impl包】
upward
03-02 2万+
Java项目 常用包的命名及理解【dao包、domain包、service包、utils包、web包、impl包】
@Repository注解的作用和用法，以及和@Mapper的区别
fenglin_smile的博客
03-30 2万+
@Repository注解的作用和用法，以及和@Mapper的区别
dao层注解@repository
热门推荐
新手源的博客
03-11 3万+
上一篇博客中第三种实例化方式说到了要用到@repository这个注解，其实根据以往这么久的开发经验，在dao层不用写这个注解spring也是可以实例化的。但是通常将dao接口注入到service层的时候，需要写@Resource这个注解（经验）。这里简单介绍下各种注解的使用。 @Resource（这个注解属于J2EE的），默认安照名称进行装配，名称可以通过name属性进行指定 ，如果没有指定n...
什么是DAO模式？
weixin_34414196的博客
07-25 1898
DAO（Data Access Object）顾名思义是一个为数据库或其他持久化机制提供了抽象接口的对象，在不暴露底层持久化方案实现细节的前提下提供了各种数据访问操作。在实际的开发中，应该将所有对数据源的访问操作进行抽象化后封装在一个公共API中。用程序设计语言来说，就是建立一个接口，接口中定义了此应用程序中...
【Java】PO、VO、DAO、BO、DTO、POJO的含义与区别
漆黑梦工厂
07-19 208
一、PO PO是“Persistent Object”的缩写，意为“持久化对象”。它通常用于表示数据库中的一条记录，即一组相关的数据。PO是由ORM（对象关系映射）框架生成或手动创建的Java对象，它们通常具有与数据库中的表相同的字段和数据类型。 在Java开发中，PO常常被用作DAO（数据访问对象）层的数据模型，以及和数据库交互的对象。 PO对象中的字段与数据库中的列相对应，每一行数据对应一个PO对象，PO对象中的字段值就是对应列的值。 二、VO VO是“Value Object”的缩写，意为“值对
java课程设计 ：使用Java的swing库及maven等知识模仿一个音乐播放器 项目已完结.zip
11-17
java课程设计 ：使用Java的swing库及maven等知识模仿一个音乐播放器 项目已完结.zip 1、该资源内项目代码经过严格调试，下载即用确保可以运行！ 2、该资源适合计算机相关专业(如计科、人工智能、大数据、数学、电子...
软件开发+Maven技术+Maven安装与配置+基础课程
04-06
《现代Java开发者的Maven实战手册：构建·管理·优化》不仅涵盖了Maven的基础知识和核心概念，还通过一系列精心设计的实战案例，引导学员探索Maven在实际项目中的应用，从而帮助他们提升构建和管理Java项目的效率和...
欢迎使用达内Maven服务.zip_mevan配置达内_达内java_达内maven_达内maven配置_达内配置maven
09-20
java的maven配置，有达内和阿里云的安装配置
课程作业-课程作业系统-课程作业系统源码-课程作业管理系统-基于Web的课程作业系统设计与实现-课程作业系统设计与实现-java
03-30
课程作业-课程作业系统-课程作业系统源码-课程作业管理系统-课程作业管理系统java代码-课程作业系统设计与实现-基于springboot的课程作业系统-基于Web的课程作业系统设计与实现-课程作业网站-课程作业网站代码-课程...
Java中的Dao是什么意思？
lin1151211427的博客
03-31 9800
DAO 模式 DAO (DataAccessobjects 数据存取对象)是指位于业务逻辑和持久化数据之间实现对持久化数据的访问。通俗来讲，就是将数据库操作都封装起来。 对外提供相应的接口 在面向对象设计过程中，有一些"套路”用于解决特定问题称为模式。 DAO 模式提供了访问关系型数据库系统所需操作的接口，将数据访问和业务逻辑分离对上层提供面向对象的数据访问接口。 从以上 DAO 模式使用可以看出，DAO 模式的优势就在于它实现了两次隔离。 1、隔离了数据访问代码和业务逻辑代码。业务逻辑代码直接调用DAO方
java万能DAO
04-24
所有业务逻辑类皆可调用该类 package com.parddu.dao; import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method; import java.sql.Connection; import java.sql.PreparedStatement; import java.sql.ResultSet; import java.sql.ResultSetMetaData; import java.sql.SQLException; import java.util.ArrayList; import java.util.HashMap; import java.util.List; /** * 通用DAO类 * @author parddu * @version Sep 29, 2010 10:16:23 AM */ public class CommonDAO { /** * 修改数据 * @param sql sql语句 * @param param 参数列表 * @return 修改记录行数 */ public int update(String sql,List param){ int row = -1; Connection conn = null; PreparedStatement update = null; try { conn = DButil.getConn(); update = conn.prepareStatement(sql); this.setParam(update, param); row = update.executeUpdate(); } catch (Exception e) { throw new RuntimeException(e.getMessage()); } finally{ DButil.closeConn(update, conn); } return row; } /** * 查询数据 * @param sql sql语句 * @param param 参数 * @return 结果集HashMap<列名,值对象> */ public List<HashMap> query(String sql,List param) { List<HashMap> list = new ArrayList<HashMap>(); Connection conn = null; PreparedStatement query = null; ResultSet rs = null; try { conn = DButil.getConn(); query = conn.prepareStatement(sql); this.setParam(query, param); rs = query.executeQuery(); if(rs!=null){ //取得所有的列名 ResultSetMetaData rsmd = rs.getMetaData(); int columnCount = rsmd.getColumnCount(); String[] columnNameArray = new String[columnCount]; for(int i=0;i<columnCount;i++){ columnNameArray[i] = rsmd.getColumnName(i+1); } //读取结果 while(rs.next()){ HashMap<String,Object> hm = new HashMap<String,Object>(); for(String cn : columnNameArray){ hm.put(cn, rs.getObject(cn)); } list.add(hm); } } } catch (Exception e) { throw new RuntimeException(e.getMessage()); } finally{ DButil.closeConn(rs,query, conn); } return list; } /** * 查询数据 * @param sql sql语句 * @param param 参数 * @return 结果集List<实体对象> */ public List query(String sql,List param,Class cla){ List list = new ArrayList(); Connection conn = null; PreparedStatement query = null; ResultSet rs = null; try { conn = DButil.getConn(); query = conn.prepareStatement(sql); this.setParam(query, param); rs = query.executeQuery(); if(rs!=null){ //取得所有的列名 ResultSetMetaData rsmd = rs.getMetaData(); int columnCount = rsmd.getColumnCount(); String[] columnNameArray = new String[columnCount]; for(int i=0;i<columnCount;i++){ columnNameArray[i] = rsmd.getColumnName(i+1); } //得到所有列和方法匹配的项 List<PropertyMthod> mList = new ArrayList<PropertyMthod>(); for(String columnName : columnNameArray){ Method m = this.getMethod(cla,columnName); if(m!=null){ PropertyMthod pm = new PropertyMthod(m,columnName); mList.add(pm); } } //读取结果 while(rs.next()){ Object o = cla.newInstance(); for(PropertyMthod pm : mList){ this.invokeSetMethod(o, pm.getMethod(), rs, pm.getColumn()); } list.add(o); } } } catch (Exception e) { throw new RuntimeException(e.getMessage()); } finally{ DButil.closeConn(rs,query, conn); } return list; } /** * 调用目标对象的set方法 * @param o 目标对象 * @param m set方法 * @param rs 结果集 * @param columnName 列名 * @throws SecurityException * @throws NoSuchMethodException * @throws IllegalArgumentException * @throws IllegalAccessException * @throws InvocationTargetException */ private void invokeSetMethod(Object o,Method m,ResultSet rs,String columnName) throws SecurityException, NoSuchMethodException, IllegalArgumentException, IllegalAccessException, InvocationTargetException{ String paramType = m.getParameterTypes()[0].getName(); paramType = paramType.substring(paramType.lastIndexOf(".")+1); /*****特殊类型处理******/ if("Integer".equals(paramType)){ paramType = "Int"; } String strName = "get" + this.firstUpper(paramType); Method rsMethod = rs.getClass().getDeclaredMethod(strName, String.class); m.invoke(o, rsMethod.invoke(rs, columnName)); } /** * 匹配指定列名的set方法 * @param o * @param column * @return * @throws NoSuchMethodException * @throws SecurityException */ private Method getMethod(Class o,String column) throws SecurityException, NoSuchMethodException{ Method m = null; List<String> strList = new ArrayList<String>(); /********set方法转换设置***********/ strList.add(column); //去掉下划线stu_name--->stuName strList.add(this.delLine(column,"_")); boolean flage = false; Method[] mlist = o.getDeclaredMethods(); for(Method tempm : mlist){ for(String s:strList){ String name = "set"+this.firstUpper(s); if(tempm.getName().equals(name)){ m=tempm; flage = true; break; } } if(flage){ break; } } if(!flage){ System.out.println("查询列名" + column + "在实体中无方法名匹配，值将不会被设置！"); } return m; } /** * 删除列分割符 * @return */ private String delLine(String str,String fg){ String result = str; if(str.indexOf(fg)!=-1){ result = str.substring(0,str.indexOf(fg))+ this.firstUpper(str.substring(str.indexOf(fg)+1)); result = delLine(result,fg); } return result; } /** * 将给定字符串首字母修改为小写 * @param str 字符串 * @return 转换后的字符串 */ private String firstUpper(String str){ return (str.charAt(0)+"").toUpperCase()+str.substring(1); } /** * 设置参数 * @param ps 预编译对象 * @param param 参数集合 * @throws SQLException */ private void setParam(PreparedStatement ps,List param) throws SQLException{ if(param!=null&&param;.size()>0){ for(int i=0;i<param.size();i++){ ps.setObject(i+1, param.get(i)); } } } }
ibatis dao包
03-02
ibatis dao 包ibatis dao 包ibatis dao 包ibatis dao 包ibatis dao 包ibatis dao 包ibatis dao 包ibatis dao 包ibatis dao 包ibatis dao 包
《软件工程导论》知识点期末复习整理
早睡早起
04-12 1万+
一、软件工程概述 1 软件和硬件的不同 硬件 人工制造 易磨损（硬件磨损后可以使用备件替换） 使用标准化组件制造 相对简单 制造出来后一般不改变 软件 开发出来的 易退化（需求的不断变更是软件退化的根本原因） 自定义组件 较为复杂 开发出来结果后可能会经常改变 2 软件的概念 软件 = 程序 + 数据 + 文档 程序：按事先设计的功能和性能需求执行的指令序列 数据：程序能正常操纵信息的数据结构 文档：与程序开发、维护和使用有关的图文材料 3 软件的本质 具有产品和产品交
java的(PO,VO,BO,DAO,POJO)解释
01-06 1622
PO(persistant object) 持久对象 在o/r映射的时候出现的概念，如果没有o/r映射，没有这个概念存在了。通常对应数据模型(数据库),本身还有部分业务逻辑的处理。可以看成是与数据库中的表相映射的java对象。最简单的PO就是对应数据库中某个表中的一条记录，多个记录可以用PO的集合。PO中应该不包含任何对数据库的操作。 VO(value object) 值对象 通常用于业务层之
JAVA实现DAO层基本CRUD操作
Kei's Blog
05-17 4907
随着shh2框架各种操作的便利性，越来越多的Java WEB开发人员选择通过加入这些框架以提高开发效率，但是，如果在不了解这些框架使用的场合的情况下，一拿到项目就盲目地选择这些框架进行系统架构的搭建，就有可能造成很多没必要的资源浪费。       在项目开发中，对数据库的CRUD操作我们一般都是无法避免的操作，虽然hibernate封装的很完美，但是，由于本人对这个框架的底层原理不是很了解，每次
使用IDEA 创建 MAVEN JAVA 项目,对创建的DAO实现类进行增删改查以及测试(内含源码及详细解释)
qq_40245464的博客
12-21 1358
题目 使用IDEA 创建 MAVEN JAVA 项目 根据下图 在mysql数据库中创建员工表(T_Employee) 创建实体类 Employee 并创建DAO 层(使用JDBC技术) 以及测试类 对创建的DAO实现类进行增删改查进行测试 项目目录结构 1.在数据库中创建表T_Employee(大小写无所谓) DROP TABLE IF EXISTS t_employe...
Java中的导包
玩垃圾的人
08-05 3693
在Java中经常有输出语句 public class test2 { public static void main(String[] args) { System.out.println(1); } } 但是如果有导包，那么就不用写System. import static java.lang.System.*; public class test2 {
在JavaWeb项目中的普通Util类调用dao层的方法
过客璇璇的博客
02-21 3578
只需要加上这几行就行 static String paths[] = {"spring/applicationContext.xml"}; static ApplicationContext ctx = new ClassPathXmlApplicationContext(paths); static BookService bookService = ctx.get...
Maven相关知识
最新发布
dyf4281的专栏
06-15 1007
exclusions：考虑这样一种情况，我们的projectA依赖于projectB，然后projectB又依赖于projectC，但是在projectA里面我们不需要projectB依赖的projectC，那么这个时候我们就可以在依赖projectB的时候使用exclusions元素下面的exclusion排除projectC。这种类型的依赖性是不可传递的。compile：这是它的默认值，这种类型很容易让人产生误解，以为只有在编译的时候才是需要的，其实这种类型表示所有的情况都是有用的，包括编译和运行时。
java中maven配置
10-17
Maven是一个Java项目管理工具，可以帮助我们自动化构建、依赖管理、测试和部署Java项目。在使用Maven之前，需要先进行配置。 1. 下载Maven并解压缩到本地目录。 2. 配置环境变量，将Maven的bin目录添加到PATH中。 3...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

GCTTTTTT

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值