精华内容
下载资源
问答
  • 一周的接口编写总结

    2016-05-27 17:36:25
    编写一个与数据库相对应的实体类。 2.编写对应访问数据数据库连接的类,包含增删改查等方法。 3.编写DAO类,用DAO类对象,对数据库进行操作二 接口提供 1 编写一个接口,包含取得数据的方法 2 编写客户端想要...

    一 数据流程
    数据库表已建好:

    1.编写一个与数据库相对应的实体类。
    2.编写对应访问数据数据库连接的类,包含增删改查等方法。
    3.编写DAO类,用DAO类对象,对数据库进行操作

    二 接口提供
    1 编写一个接口,包含取得数据的方法
    2 编写客户端想要数据的实体类,
    3 对应接口的实现类,在此类中填充取方法的内容,利用DAO类取得数据库中的数据,赋值到客户端想要数据类的对象中并 返回这个对象。

    展开全文
  • 目录 1.新建Web Project 项目,建立Util工具包,新建JDBCUtil类,导入jdbc-connector-java包 2.编写JDBCUtil类的相关...新建entity实体包,编写对应的实体类 5.新建Dao层,创建UserDao接口 6.新建DaoImp层,创建...

    目录

    1.新建Web Project 项目,建立Util工具包,新建JDBCUtil类,导入jdbc-connector-java包

    2.编写JDBCUtil类的相关内容

    3.右键JDBC类->运行方式->Java应用程序,测试是否连接成功

             4.新建entity实体包,编写对应的实体类

    5.新建Dao层,创建UserDao接口

    6.新建DaoImp层,创建UserDaoImp类,实现UserDao接口方法

    7.创建单元测试类


    工具:MyEclipse 2017 CI

    JDBC驱动下载:链接:https://pan.baidu.com/s/1I90tu8pO_0lnx996k4_S0A   密码:pdax

    项目源码:链接:https://pan.baidu.com/s/1YFKtQc6REI7IWiyNXFzjmA 密码:c6oy

    1.新建Web Project 项目,建立Util工具包,新建JDBCUtil类,导入jdbc-connector-java包

    2.编写JDBCUtil类的相关内容

    package com.ly.util;
    
    import java.sql.Connection;
    import java.sql.DriverManager;
    import java.sql.PreparedStatement;
    import java.sql.ResultSet;
    
    public class JDBCUtil {
    	public static Connection getConnection(){
    		try {
    			//反射的技术将驱动加进来
    			Class.forName("com.mysql.jdbc.Driver");
    			//第二步:
    			Connection conn=DriverManager.getConnection("jdbc:mysql://localhost:3306/shop?characterEncoding=utf-8&useSSL=true", "root", "root");
    			System.out.println("数据库连接成功!");
    			return conn;
    		} catch (Exception e) {
    			e.printStackTrace();
    		}
    		return null;
    	}
    	
    	
    	/**
    	 * 
    	 * @param args
    	 * 关闭相关的资源
    	 * 
    	 */
    	public static void closeAll(ResultSet  rs,PreparedStatement  pstm,Connection conn){
    		
    		try{
    			
    			if(rs!=null){rs.close();}
    			if(pstm!=null){pstm.close();}
    			if(conn!=null){conn.close();}
    		}catch (Exception e) {
    			e.printStackTrace();
    		}
    	}
    	
    	 public static void main(String[] args) {
    		   getConnection();
    	}
    
    }
    

    3.右键JDBC类->运行方式->Java应用程序,测试是否连接成功

    有人可能会问,这不是WebProject吗?怎么可以用Java应用程序方式来运行,这是因为在JDBCUtil中加了main函数。加了main函数的类是可以直接用Java应用程序方式来运行的。这也可以当作测试来用,当然最好是用Java的单元测试来验证是否连接成功。

    4.新建entity实体包,编写对应的实体类

    一般情况下都是一张数据表对应一个实体类。

    先看一下数据库中的user表:

    编写实体类:

    package com.ly.entity;
    /***
     * 
     * @author HDLB601T1
     *  封装用户数据
     */
    public class User {
       
    	 private int id;
    	 private String  username;
    	 private String pwd;
    	 private int status;
    	 private int role;
    	 
    	public User() {
    		super();
    	}
    	public User(int id, String username, String pwd, int status, int role) {
    		super();
    		this.id = id;
    		this.username = username;
    		this.pwd = pwd;
    		this.status = status;
    		this.role = role;
    	}
    	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 getPwd() {
    		return pwd;
    	}
    	public void setPwd(String pwd) {
    		this.pwd = pwd;
    	}
    	public int getStatus() {
    		return status;
    	}
    	public void setStatus(int status) {
    		this.status = status;
    	}
    	public int getRole() {
    		return role;
    	}
    	public void setRole(int role) {
    		this.role = role;
    	}
    	@Override
    	public String toString() {
    		return "User [id=" + id + ", username=" + username + ", pwd=" + pwd + ", status=" + status + ", role=" + role
    				+ "]";
    	}
    }
    

    此时的项目结构:

    5.新建Dao层,创建UserDao接口

    package com.ly.dao;
    
    import java.util.List;
    
    import com.ly.entity.User;
    
    
    public interface UserDao {
    	   
    	/**
    	 * 插入一条数据:
    	 * 返回值:int
    	 * 参数:User
    	 * insert  into user values(7,'qq','123',1,2);
    	 */
    	public  int  insertUser(User u);
    	
    	
    	/**
    	 * 
    	 * @param id
    	 * @return  
    	 * 删除用户
    	 */
    	public  int   deleteUser(int id );
    	
    
    	/***
         * 
         * @param u
         * @return
         * 修改用户
         * 
         */
    	public int  updateUser(User u);
    	
    	/**
    	 * 
    	 *根据页码进行查询
    	 *返回值:
    	 *参数:page  ,index
    	 *
    	 */
    	public  List<User>   listByPage(int index,int pageSize);
    	
    	/***
    	 *登录的业务
    	 *查找:
    	 *select * from user where user=?  and pwd=?
    	 *参数:
    	 *返回值:
    	 */
    	public  User  findUserByNamePwd(String username,String pwd);
    	
    	
    	public User findUserById(int id);
    	
    	
    }

    6.新建DaoImp层,创建UserDaoImp类,实现UserDao接口方法

    package com.ly.daoimp;
    
    import java.sql.Connection;
    import java.sql.PreparedStatement;
    import java.sql.ResultSet;
    import java.sql.SQLException;
    import java.util.ArrayList;
    import java.util.List;
    
    import com.ly.dao.UserDao;
    import com.ly.entity.User;
    import com.ly.util.JDBCUtil;
    
    public class UserDaoImp implements UserDao {
    
    	@Override
    	public int insertUser(User u) {
    		// 连接数据库
    		Connection conn = JDBCUtil.getConnection();
    		PreparedStatement pstm = null;
    		// 创建一个查询窗口
    		try {
    			String sql = "insert into user values(?,?,?,?,?)";
    			pstm = conn.prepareStatement(sql);
    			// 需要设置真正的值insert into user values(7,'qq','123',1,2);
    			pstm.setInt(1, u.getId());
    			pstm.setString(2, u.getUsername());
    			pstm.setString(3, u.getPwd());
    			pstm.setInt(4, u.getStatus());
    			pstm.setInt(5, u.getRole());
    
    			// 执行sql
    			int num = pstm.executeUpdate();
    			return num;
    
    		} catch (SQLException e) {
    			e.printStackTrace();
    		} finally {
    			JDBCUtil.closeAll(null, pstm, conn);
    		}
    		return 0;
    	}
    
    	@Override
    	public int deleteUser(int id) {
    
    		Connection connection = JDBCUtil.getConnection();
    		PreparedStatement pstm = null;
    		try {
    			String sqlString = "delete from user where id=?";
    			pstm = connection.prepareStatement(sqlString);
    			pstm.setInt(1, id);
    			int num = pstm.executeUpdate();
    			return num;
    		} catch (SQLException e) {
    			e.printStackTrace();
    		} finally {
    			JDBCUtil.closeAll(null, pstm, connection);
    		}
    		return 0;
    	}
    
    	@Override
    	public int updateUser(User u) {
    		Connection connection=JDBCUtil.getConnection();
    		PreparedStatement pstm=null;
    		try {
    			String sqlString="update user set user=?,pwd=? ,status=?, role=? where id=? ";
    			pstm=connection.prepareStatement(sqlString);
    			pstm.setString(1, u.getUsername());
    			pstm.setString(2, u.getPwd());
    			pstm.setInt(3, u.getStatus());
    			pstm.setInt(4, u.getRole());
    			pstm.setInt(5, u.getId());
    			
    			int num=pstm.executeUpdate();
    			return num;
    			
    		} catch (SQLException e) {
    			e.printStackTrace();
    		}
    		finally {
    			JDBCUtil.closeAll(null, pstm, connection);
    		}
    		return 0;
    	}
    
    	@Override
    	public List<User> listByPage(int index, int pageSize) {
    		Connection connection=JDBCUtil.getConnection();
    		PreparedStatement pstm=null;
    		ResultSet rs=null;
    		List<User> uList=new ArrayList<User>();
    	    try {
    			String sqlString="select * from user limit ?,?";
    			pstm=connection.prepareStatement(sqlString);
    			pstm.setInt(1, (index-1)*pageSize);
    			pstm.setInt(2, pageSize);
    			rs=pstm.executeQuery();
    			
    			while (rs.next()) {
    			     User user=new User(rs.getInt(1),rs.getString(2),rs.getString(3),rs.getInt(4),rs.getInt(5));
    			     uList.add(user);
    			}
    			
    			return uList;
    		} catch (Exception e) {
    			e.printStackTrace();
    		}finally {
    			JDBCUtil.closeAll(rs, pstm, connection);
    		}
    		
    		return null;
    	}
    
    	@Override
    	public User findUserByNamePwd(String username, String pwd) {
    		Connection connection=JDBCUtil.getConnection();
    		PreparedStatement pstm=null;
    		ResultSet rs=null;
    		User user=null;
    		
    		try {
    			
    			String sqlString="select * from user where user=?&&pwd=?";
    			pstm=connection.prepareStatement(sqlString);
    			pstm.setString(1, username);
    			pstm.setString(2, pwd);
    			
    			rs=pstm.executeQuery();
    			while (rs.next()) {
    				user=new User(rs.getInt(1),rs.getString(2),rs.getString(3),rs.getInt(4),rs.getInt(5));
    			}
    			
    			return user;	
    			
    		} catch (SQLException e) {
    			// TODO: handle exception
    		}finally {
    			JDBCUtil.closeAll(rs, pstm, connection);
    		}
    		return null;
    	}
    
    	@Override
    	public User findUserById(int id) {
    		Connection connection=JDBCUtil.getConnection();
    		PreparedStatement pstm=null;
    		ResultSet rs=null;
    		User user=null;
    		try {
    			String sqlstring="select * from user where id=?";
    			pstm=connection.prepareStatement(sqlstring);
    			pstm.setInt(1, id);
    			rs=pstm.executeQuery();
    			while (rs.next()) {
    				user=new User(rs.getInt(1),rs.getString(2),rs.getString(3),rs.getInt(4),rs.getInt(5));	
    			}
    			
    			return user;
    			
    		} catch (SQLException e) {
    			e.printStackTrace();
    		}finally {
    			JDBCUtil.closeAll(rs, pstm, connection);
    		}
    		return null;
    	}
    
    }
    

    项目结构:

    7.创建单元测试类

    点击UserDaoImp类右建->新建->其他

    测试类代码:

    package test;
    
    
    import java.util.List;
    
    import org.junit.Test;
    
    import com.ly.daoimp.UserDaoImp;
    import com.ly.entity.User;
    
    public class UserDaoImpTest {
    	
    	private UserDaoImp uDaoImp=new UserDaoImp();
    
    	@Test
    	public void testInsertUser() {
    		User user=new User();
    		user.setUsername("测试");
    		user.setPwd("123456");
    		user.setRole(1);
    		user.setStatus(0);
    		int num=uDaoImp.insertUser(user);
    		System.out.println(num);
    		if(num>0){
    			System.out.println("插入成功");
    		}
    	}
    
    	@Test
    	public void testDeleteUser() {
    		int num=uDaoImp.deleteUser(10);
    		if (num>0) {
    			System.out.println("删除数据成功");
    		}
    	}
    
    	@Test
    	public void testUpdateUser() {
    		User u=new User(4,"吴家伟","741852963",0,0);
    		int num=uDaoImp.updateUser(u);
    		if (num>0) {
    			System.out.println("更新数据成功");
    		}
    	}
    
    	@Test
    	public void testListByPage() {
    		
    		List<User> users=uDaoImp.listByPage(1, 5);
    	    for (User user : users) {
    	    	System.out.println(user);
    		}
    		
    		
    	}
    
    	@Test
    	public void testFindUserByNamePwd() {
    		User user=uDaoImp.findUserByNamePwd("ly", "123");
    		if (user!=null) {
    			System.out.println(user);
    		}
    	}
    
    	@Test
    	public void testFindUserById() {
    		User user=uDaoImp.findUserById(9);
    		if (user!=null) {
    			System.out.println(user);
    		}
    		 
    	}
    
    }
    

     

    点击UserDaoImpTest类右建->运行方式->JUnit测试

    说明连接数据库成功,可以通过JDBC驱动来操作Mysql的ti'a添加和删除

    展开全文
  • SpringBoot数据访问——整合JPA 文章目录SpringBoot数据访问——...编写数据库中表对应的实体类Bean4.2 编写操作数据的接口repository4.3 配置JPA4.4 编写控制层实现CRUD 0.JPA简介 JPA:Java persistence API(Java...

    SpringBoot数据访问——整合JPA

    0.JPA简介

    JPA:Java persistence API(Java持久化接口),是定义了对象关系映射(ORM)以及实体对象持久化的标准接口,在SpringBoot中JPA基于Hibernate。

    1.导入依赖

    maven项目中的pom.xml,添加依赖如下:处了springboot的启动器外还有:JPA,Web模块,MySQL,Lombok

            <!--  JPA -->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-data-jpa</artifactId>
                <version>2.2.4.RELEASE</version>
            </dependency>
    
            <!-- Web 模块 -->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
            </dependency>
    
            <!-- MySQL -->
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <version>5.1.46</version>
            </dependency>
    
            <!-- Java效率工具Lombok -->
            <dependency>
                <groupId>org.projectlombok</groupId>
                <artifactId>lombok</artifactId>
                <version>1.18.10</version>
            </dependency>
    

    2.配置数据连接

    数据源使用默认的,数据库配置如下:

    默认的application.properties

    #mysql配置
    spring.datasource.driver-class-name=com.mysql.jdbc.Driver
    spring.datasource.url=jdbc:mysql://*.*.*.*:3306/springboot_demo
    spring.datasource.username=账号
    spring.datasource.password=密码
    

    yml格式:

    #配置数据源
    spring:
      datasource:
        username: 账号
        password: 密码
        url: jdbc:mysql://*.*.*.*:3306/springboot_demo
        driver-class-name: com.mysql.jdbc.Driver
    

    3.初始化测试数据表

    这里就用了一个简单了表,包含id(主键且自增),english,chinese这三个字段。

    在这里插入图片描述

    4.使用JPA编写操作数据的代码

    4.1.编写数据库中表对应的实体类Bean

    entity包下建立word类:

    import lombok.Data;
    
    import javax.persistence.*;
    
    import lombok.AllArgsConstructor;
    import lombok.Data;
    import lombok.NoArgsConstructor;
    
    import javax.persistence.*;
    
    
    @Data
    @AllArgsConstructor
    @NoArgsConstructor
    @Entity
    @Table(name = "word")//指明该类和数据表映射;省略则默认为类名首字母小写
    public class Word {
        @Id
        @GeneratedValue(strategy = GenerationType.IDENTITY)//主键自增
        private Integer id;
        @Column(name = "english")//这是和数据表对应的一个列;省略则列名=属性名
        private String english;
        @Column
        private String chinese;
    }
    
    

    这里使用了Lombok插件中的注解 @Data

    • @Data注解在类自动生成setter/getter、equals、canEqual、hashCode、toString方法,如为final属性,则不会为该属性生成setter方法。
    • @AllArgsConstructor 所有参数的构造方法
    • @NoArgsConstructor 无参构造方法

    其他注释均为JPA的:

    • @Table(name = “word”)//指明该类和数据表映射;省略则默认为类名首字母小写
    • @Id标注为主键
    • @GeneratedValue(strategy = GenerationType.IDENTITY)//自增
    • @Column(name = “english”)//标注为列;省略则列名=属性名

    更多关于Lombok的安装与使用可查看:IntelliJ IDEA Java高率开发插件Lombok

    4.2 编写操作数据的接口repository

    首先JPA提供了三种repository接口,各自封装了不同的基本功能:

    • CrudRepository<T, ID extends Serializable>:最基本的对实体类的添删改查操作
    • PagingAndSortingRepository<T, ID extends Serializable>:基本的分页与排序功能
    • JpaRepository<T, ID extends Serializable>:提供了JPA的相关功能

    repository包下建WordRepository接口类:

    继承自CrudRepository<Word, Integer>,泛型的第一为上述的实体类Bean,第二个为主键数据类型,继承了该接口后便拥有了基本的CRUD操作。

    
    import com.piao.springboot_jpa.entity.Word;
    import org.springframework.data.jpa.repository.JpaRepository;
    
    //操作数据的接口repository 使其拥有常规CRUD功能
    public interface WordRepository extends CrudRepository<Word, Integer> {
    }
    
    

    其中CrudRepository接口源码如下,看看有什么直接可用的方法:(注释简单说明)

    @NoRepositoryBean
    public interface CrudRepository<T, ID> extends Repository<T, ID> {
        <S extends T> S save(S var1);//保存数据,用于插入或修改数据
    
        <S extends T> Iterable<S> saveAll(Iterable<S> var1);//保存整个可迭代的集合中的数据,比如list<Word>
    
        Optional<T> findById(ID var1);//按照id查找
    
        boolean existsById(ID var1);//按照id查找,有返回true,否则false
    
        Iterable<T> findAll();//查询所有,以可迭代的集合返回,比如List<word>
    
        Iterable<T> findAllById(Iterable<ID> var1);//查询集合中所有符和条件的数据,以可迭代的集合返回,比如List<word>
    
        long count();//数据量计数
    
        void deleteById(ID var1);//按照id删除
    
        void delete(T var1);//删除指定实体类对应的数据
    
        void deleteAll(Iterable<? extends T> var1);//删除集合中所有符和条件的数据
    
        void deleteAll();//全删,慎用!!
    }
    

    其他两个在此不赘述,自行查看源码看看,都是一些常规方法,帮我们省去了开发时间。

    4.3 配置JPA

    JPA底层由Hibernate实现,有的配置其实就是配置Hibernate相关的东西。

    yml格式:

    show-sql: true使其在控制台显示操作数据的SQL语句;

    ddl-auto: update 更新或创建数据表,即使上述没有初始化数据表,JPA也会根据实体类的注释创建对应的数据表。

    #配置数据源
    spring:
      datasource:
        username: root
        password: 23573
        url: jdbc:mysql://47.107.229.140:3306/springboot_demo?useUnicode=true&characterEncoding=utf-8
        driver-class-name: com.mysql.jdbc.Driver
      jpa:
        hibernate:
    #      更新或创建数据表
          ddl-auto: update
        show-sql: true
    #    控制台显示操作数据的SQL语句
    

    4.4 编写控制层实现CRUD

    功能包括基本的CRUD操作:

    • 添加单词信息
    • 根据id查询单词信息
    • 根据id更新单词信息
    • 根据id删除单词信息
    • 查询所有单词
       @Autowired
       WordRepository wordRepository;
    

    将业务对象WordRepository注入后便可直接使用自带的CRUD方法操作数据。

    这里加了详细且原始的数据校验判空处理,当然有更优雅的方式…这里就不展开了。

    推荐这位大佬的博客:啥?听说你还在手写复杂的参数校验?

    package com.piao.springboot_jpa.controller;
    
    import com.piao.springboot_jpa.entity.Word;
    import com.piao.springboot_jpa.repository.WordRepository;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.web.bind.annotation.GetMapping;
    import org.springframework.web.bind.annotation.PostMapping;
    import org.springframework.web.bind.annotation.ResponseBody;
    import org.springframework.web.bind.annotation.RestController;
    
    import java.util.HashMap;
    import java.util.Map;
    
    @RestController
    public class JPAController {
    
        //注入业务对象 WordRepository
        @Autowired
        WordRepository wordRepository;
        //存储预返回页面的结果对象
        private Map<String, Object> result;
    
    
        //添加单词信息
        @PostMapping("/insertWord")
        @ResponseBody
        public Map<String, Object> insertWord(Word word) {
            result = new HashMap<>();
    
            //数据校验 判空!
            if (null == word) {
                result.put("message", "插入的单词为空");
                return result;
            }
            if (null == word.getChinese() || "".equals(word.getEnglish())) {
                result.put("message", "插入的单词中文为空或者为空字符串");
                return result;
            }
            if (null == word.getChinese() || "".equals(word.getChinese())) {
                result.put("message", "插入的单词中文为空或者为空字符串");
                return result;
            }
    
            wordRepository.save(word);//插入单词,插入数据使用save
    
            result.put("message", "插入单词成功");
            return result;
        }
    
        //根据id查询单词信息
        @GetMapping("/getWordById")
        @ResponseBody
        public Map<String, Object> getWordById(Integer id) {
            result = new HashMap<>();
    
            //数据校验 判空!
            if (null == id) {
                result.put("message", "传入id为空");
                return result;
            }
    
            result.put("word", wordRepository.findById(id));//按照id(主键)查询getOne()
            result.put("message", "查询单词成功");
            return result;
        }
    
    
        //根据id更新单词信息
        @PostMapping("/updateWordById")
        @ResponseBody
        public Map<String, Object> updateWordById(Integer id, String english, String chinese) {
            result = new HashMap<>();
    
            //数据校验 判空!
            if (null == id) {
                result.put("message", "更新的单词id为空");
                return result;
            }
            if (null == english || "".equals(english)) {
                result.put("message", "更新的单词中文为空或者为空字符串");
                return result;
            }
            if (null == chinese || "".equals(chinese)) {
                result.put("message", "更新的单词中文为空或者为空字符串");
                return result;
            }
    
            wordRepository.save(new Word(id, english, chinese));
    
            result.put("message", "更新单词成功");
            return result;
        }
    
        //根据id删除单词信息
        @PostMapping("/deleteWordById")
        @ResponseBody
        public Map<String, Object> deleteWordById(Integer id) {
            result = new HashMap<>();
            //数据校验 判空!
            if (null == id) {
                result.put("message", "输入的单词id为空");
                return result;
            }
            wordRepository.deleteById(id);//根据id删除单词信息
            result.put("message", "删除单词成功");
            return result;
        }
    
        //查询所有单词
        @GetMapping("/getAllWord")
        @ResponseBody
        public Map<String, Object> getAllWord() {
            result = new HashMap<>();
            result.put("wordList",wordRepository.findAll());//查询所有单词
            result.put("message", "查询所有单词成功");
            return result;
        }
    
    }
    

    这五个接口均用postman测试过,操作数据正常,数据校验的判空处理正常。

    展开全文
  • 编写实体类 编写mybatis配置文件 编写接口 编写接口对应的mapper映射文件 注册映射文件 测试 1. MyBatis-Spring简介 官网:www.mybatis.org/spring/zh/index.html 1.1 什么是MyBatis-Spring MyBatis-...

    先回忆一下MyBatis,程序的编写步骤为:

    1. 导包:mybatis、数据库驱动包、junit;
    2. 编写实体类
    3. 编写mybatis配置文件
    4. 编写接口
    5. 编写接口对应的mapper映射文件
    6. 注册映射文件
    7. 测试

    1. MyBatis-Spring简介

    官网:www.mybatis.org/spring/zh/index.html

    1.1 什么是MyBatis-Spring

    MyBatis-Spring 会帮助你将 MyBatis 代码无缝地整合到 Spring 中。它将允许 MyBatis 参与到 Spring 的事务管理之中,创建映射器 mapper 和 SqlSession 并注入到 bean 中,以及将 Mybatis 的异常转换为 Spring 的 DataAccessException。最终,可以做到应用代码不依赖于 MyBatis,Spring 或 MyBatis-Spring。

    有一个包很重要:mybatis-spring

    1.2 版本

    在开始使用 MyBatis-Spring 之前,你需要先熟悉 Spring 和 MyBatis 这两个框架和有关它们的术语。这很重要——因为本手册中不会提供二者的基本内容,安装和配置教程。

    MyBatis-Spring 需要以下版本:

    MyBatis-Spring MyBatis Spring框架 Spring Batch Java
    2.0 3.5+ 5.0+ 4.0+ Java 8+
    1.3 3.4+ 3.2.2+ 2.1+ Java 6+

    2 . 基础知识

    2.1 安装

    要使用 MyBatis-Spring 模块,只需要在类路径下包含 mybatis-spring-1.3.2.jar 文件和相关依赖即可。

    如果使用 Maven 作为构建工具,仅需要在 pom.xml中加入以下代码即可:

    Maven中导入MyBatis-Springjar包:

    <!-- https://mvnrepository.com/artifact/org.mybatis/mybatis-spring -->
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis-spring</artifactId>
        <version>1.3.2</version>
    </dependency>
    

    2.2 配置

    要和 Spring 一起使用 MyBatis,需要在 Spring 应用上下文中定义至少两样东西:一个 SqlSessionFactory 和至少一个数据映射器类。

    在 MyBatis-Spring 中,可使用 SqlSessionFactoryBean来创建 SqlSessionFactory。 要配置这个工厂 bean,只需要把下面代码放在 Spring 的 XML 配置文件中:

    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
      <property name="dataSource" ref="dataSource" />
    </bean>
    

    注意:SqlSessionFactory 需要一个 DataSource(数据源)。 这可以是任意的 DataSource,只需要和配置其它 Spring 数据库连接一样配置它就可以了。

    2.3 SqlSessionFactoryBean

    在基础的 MyBatis 用法中,是通过 SqlSessionFactoryBuilder 来创建 SqlSessionFactory 的。 而在 MyBatis-Spring 中,则使用 SqlSessionFactoryBean 来创建。

    需要注意的是 SqlSessionFactoryBean 实现了 Spring 的 FactoryBean 接口。这意味着由 Spring 最终创建的 bean 并不是 SqlSessionFactoryBean 本身,而是工厂类(SqlSessionFactoryBean)的 getObject() 方法的返回结果。这种情况下,Spring 将会在应用启动时为你创建 SqlSessionFactory,并使用 sqlSessionFactory 这个名字存储起来。

    属性:

    需要注意的是,这个配置文件并不需要是一个完整的 MyBatis 配置。确切地说,任何环境配置(<environments>),数据源(<DataSource>)和 MyBatis 的事务管理器(<transactionManager>)都会被忽略SqlSessionFactoryBean 会创建它自有的 MyBatis 环境配置(Environment),并按要求设置自定义环境的值。

    如果 MyBatis 在映射器类对应的路径下找不到与之相对应的映射器 XML 文件,那么也需要配置文件。这时有两种解决办法:第一种是手动在 MyBatis 的 XML 配置文件中的 <mappers> 部分中指定 XML 文件的类路径;第二种是设置工厂 bean 的 mapperLocations 属性。

    mapperLocations 属性接受多个资源位置。这个属性可以用来指定 MyBatis 的映射器 XML 配置文件的位置。

    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
      <property name="dataSource" ref="dataSource" />
      <property name="mapperLocations" value="classpath*:sample/config/mappers/**/*.xml" />
    </bean>
    

    2.4 SqlSession

    在 MyBatis 中,你可以使用 SqlSessionFactory 来创建 SqlSession。一旦你获得一个 session 之后,你可以使用它来执行映射了的语句,提交或回滚连接,最后,当不再需要它的时候,你可以关闭 session。使用 MyBatis-Spring 之后,你不再需要直接使用 SqlSessionFactory 了,因为你的 bean 可以被注入一个线程安全的 SqlSession,它能基于 Spring 的事务配置来自动提交、回滚、关闭 session。

    SqlSessionTemplate:

    SqlSessionTemplate 是 MyBatis-Spring 的核心。

    作为 SqlSession 的一个实现,这意味着可以使用它无缝代替你代码中已经在使用的 SqlSessionSqlSessionTemplate 是线程安全的,可以被多个 DAO 或映射器所共享使用。

    可以使用 SqlSessionFactory 作为构造方法的参数来创建 SqlSessionTemplate 对象。

    <bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
      <constructor-arg index="0" ref="sqlSessionFactory" />
    </bean>
    

    思考问题?

    为什么使用构造器,而不直接属性;

    因为没有对应set方法;

    现在,这个 bean 就可以直接注入到你的 DAO bean 中了。你需要在 bean 中添加一个 SqlSession 属性,就像下面这样:

    public class UserDaoImpl implements UserDao {
    
      private SqlSession sqlSession;
    
      public void setSqlSession(SqlSession sqlSession) {
        this.sqlSession = sqlSession;
      }
    
      public User getUser(String userId) {
        return sqlSession.selectOne("org.mybatis.spring.sample.mapper.UserMapper.getUser", userId);
      }
    }
    

    按下面这样,注入 SqlSessionTemplate

    <bean id="userDao" class="org.mybatis.spring.sample.dao.UserDaoImpl">
       <property name="sqlSession" ref="sqlSession" />
    </bean>
    

    3. MyBatis-Spring数据访问应用程序

    案例:

    访问MyBatis的第一个程序,数据库、实体类、工具类都不变。

    创建一个MyBatis-Spring程序的步骤为:

    1、导如jar包:

    ​ mybatis、mysql驱动、junit、spring-beans、spring-context、spring-jdbc【数据源】、spring-tx【事务】、mybatis-spring整合包【最重要】

    pom.xml

    <dependencies>
    
            <!--单元测试-->
            <dependency>
                <groupId>junit</groupId>
                <artifactId>junit</artifactId>
                <version>4.11</version>
            </dependency>
    
            <!--mybatis的包-->
            <dependency>
                <groupId>org.mybatis</groupId>
                <artifactId>mybatis</artifactId>
                <version>3.5.1</version>
            </dependency>
    
            <!--连接数据库的驱动包-->
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <version>5.1.47</version>
            </dependency>
    
            <!-- spring包 -->
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-webmvc</artifactId>
                <version>4.3.9.RELEASE</version>
            </dependency>
    
            <!--mybatis-spring整合-->
            <!-- https://mvnrepository.com/artifact/org.mybatis/mybatis-spring -->
            <dependency>
                <groupId>org.mybatis</groupId>
                <artifactId>mybatis-spring</artifactId>
                <version>1.3.2</version>
            </dependency>
    
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-jdbc</artifactId>
                <version>4.3.9.RELEASE</version>
            </dependency>
    
        </dependencies>
    
        <build>
             <!--资源导出-->
            <resources>
                <resource>
                    <directory>src/main/java</directory>
                    <includes>
                        <include>**/*.xml</include>
                    </includes>
                    <filtering>false</filtering>
                </resource>
                <resource>
                    <directory>src/main/resources</directory>
                    <includes>
                        <include>**/*.xml</include>
                    </includes>
                    <filtering>false</filtering>
                </resource>
            </resources>
        </build>
    

    2、配置mybatis文件

    mybatis-config.xml只需要写一些简单的 设置,别名,mapper映射文件。
    数据库的连接配置信息则写到Spring配置文件中。

    <?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>
    
        <!--别名-->
        <typeAliases>
            <package name="org.xiao.pojo"/>
        </typeAliases>   
    
        <!--关联映射文件-->
        <mappers>
            <mapper resource="org/xiao/dao/UserDao.xml"/>
        </mappers>
    
    </configuration>
    

    3、spring配置文件

    配置数据源、sqlSessionFactory、sqlSession。

    applicationContext.xml

    <?xml version="1.0" encoding="UTF-8"?>
    <!--suppress SpringFacetInspection -->
    <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">
    
        <!--1.配置数据源,我们使用的是spring的数据源,还可以使用第三方的数据源
        dbcp,c3p0
            com.mchange.v2.c3p0.ComboPooledDataSource
            org.apache.commons.dbcp.BasicDataSource
        -->
        <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/mybatis?useSSL=true&amp;useUnicode=true&amp;characterEncoding=utf-8"/>
            <property name="username" value="root"/>
            <property name="password" value="123456"/>
        </bean>
    
        <!--2.配置SqlSessionFactory-->
        <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
            <property name="dataSource" ref="dataSource" />
            <!--关联mybatis的配置文件-->
            <property name="configLocation" value="classpath:mybatis-config.xml"/>
        </bean>
    
        <!--3.创建selSession-->
        <bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
            <constructor-arg index="0" ref="sqlSessionFactory" />
        </bean>
    
        <!--4.接口实现类注入sqlSession-->
        <bean id="userDaoImpl" class="org.xiao.dao.UserDaoImpl">
            <property name="sqlSession" ref="sqlSession"/>
        </bean>
    
    </beans>
    

    4、接口实现类增加一个属性:sqlSession

    package org.xiao.dao;
    
    import org.apache.ibatis.session.SqlSession;
    import org.xiao.pojo.User;
    
    import java.util.List;
    import org.mybatis.spring.SqlSessionTemplate;
    
    public class UserDaoImpl implements UserDao{
    
        private SqlSessionTemplate sqlSession;
    
        public void setSqlSession(SqlSessionTemplate sqlSession){
            this.sqlSession = sqlSession;
        }
    
        public List<User> selectUser() {
            UserDao mapper = sqlSession.getMapper(UserDao.class);
            return  mapper.selectUser();
        }
    }
    

    将接口的实现类交给spring来管理

    <!--4.接口实现类注入sqlSession-->
    <bean id="userDaoImpl" class="com.kuang.dao.UserDaoImpl">
        <property name="sqlSession" ref="sqlSession"/>
    </bean>
    

    4、测试

    package org.xiao.dao;
    
    import org.junit.Test;
    import org.apache.ibatis.session.SqlSession;
    import org.apache.ibatis.session.SqlSessionFactory;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    import org.xiao.pojo.User;
    import org.xiao.utils.MyBatisUtils;
    
    import java.util.List;
    
    public class UserTest {
        @Test
        public void selectUser(){
    
            ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
            UserDao userDaoImpl = (UserDao) context.getBean("userDaoImpl");
            List<User> users = userDaoImpl.selectUser();
    
            for (User user : users) {
                System.out.println(user);
            }
        }
    }
    

    5、项目结构
    在这里插入图片描述

    6、结果
    在这里插入图片描述

    展开全文
  • 使用HttpClient测试SpringMVC的接口

    千次阅读 2016-08-29 18:37:59
    最近在写SSM创建的Web项目,写到一个对外接口时需要做测试,接受json格式的数据。在线测试需要放公网地址... 由于接口接受json类型的数据,因此构造了对应的实体类,然后使用fastjson转为json,加到请求头中。 String u
  • 可以实现在Web端无需事先手工编写或自动创建任何程序代码和数据实体类的情况下, 便可在Silverlight端对Web端数据库进行增加、删除、修改、查询等数据操作。此外, 还支持访问数据库存储过程(StoredProcdures)、视图...
  • 什么是逆向工程分析数据库中数据表,自动生成Pojo(与数据库表对应的实体类)、dao 接口(数据访问接口,定义了访问数据的方法)、mapper (sql 语句映射文件,与dao层接口类一一对应)新建SpringBoot项目注意:这里使用...
  • 引用类型和原始类型具有不同的特征和用法,它们包括:大小和速度问题,这种类型以哪种类型的数据结构存储,当引用类型和原始类型用作某个的实例数据时所指定的缺省值。对象引用实例变量的缺省值为 null,而原始...
  • 4、 系统的数据要求:1、数据录入和处理的准确性和实时性。2、数据的一致性与完整性。3、数据的共享与独立性。 2.2. 系统的可行性分析 2.2.1. 技术可行性 技术上的可行性分析要考虑将来要采用的硬件和软件技术...
  • 2、 这是一组接口类,其中包括了每个要公开的数据访问方法。为每个数据库产品单独编写的DAL(数据访问层)都要实现这组接口所定义的方法 3、 也就是规定了在DAL中编写的“对用户账号进行操作的”所必须执行的方法...
  • 9.2 分布式数据库设计的数据分片、复制和分配技术 182 9.2.1 数据分片 182 9.2.2 数据复制和分配 184 9.2.3 分片、分配和复制示例 185 9.3 分布式数据库系统的类型 187 9.4 分布式数据库中的...
  • java 面试题 总结

    2009-09-16 08:45:34
    引用类型和原始类型具有不同的特征和用法,它们包括:大小和速度问题,这种类型以哪种类型的数据结构存储,当引用类型和原始类型用作某个的实例数据时所指定的缺省值。对象引用实例变量的缺省值为 null,而原始...
  • 实体生成规则切换为包装类型,不再采用基本数据类型,为实体类生成添加显示默认构造方法(感谢@h2sopull request). 2019.01.06 修复处理number/decimal(x,x)类型逻辑(感谢@arthaschan反馈). 修复...
  • JAVA面试题最全集

    2010-03-13 13:09:10
    要掌握Collection相关的接口类的使用 56.使用StringBuffer与String进行字符串连接时有何区别? 57.调用Thread类的destroy()方法有什么后果? 58.多线程,用什么关键字修饰同步方法?stop()和suspend()方法...
  • 乐优商城.xmind

    2019-03-31 17:26:39
    ly-item-interface:主要是对外暴露API接口及相关实体类 ly-item-service:所有业务逻辑及内部使用接口 创建父工程ly-item ly-item-interface ly-item-service 依赖 启动器 application.yml 添加商品...
  • 其中,扩展数据和扩展字典是标识实体的一种手段,SummaryInfo对象提供了访问图形特性的接口,绘图顺序则用于调整图形对象显示层次。 第12章探讨了在VBA开发应用程序过程中可能会用到几种技术和技巧。调试应用...
  •  首页需要的数据是热门商品的信息,商品信息需要建立一个Bean对象,存储内容是商品的id、商品名称、商品单价、商品类别、商品数量、商品详细信息、商品成色、商品附带的图片地址、热门程度、发表用户的id、留言的...
  • 在先左后右原则下,根据访问根结点次序,二叉树遍历分为三:前序遍历、中序遍历和后序遍历。 (1)前序遍历 先访问根结点,然后遍历左子树,最后遍历右子树;并且在遍历左、右子树时,仍需先访问根结点,...
  • LAMA语言模型分析,提供Transformer-XL/BERT/ELMo/GPT预训练语言模型统一访问接口、CommonsenseQA:面向常识英文QA挑战、中文知识图谱资料、数据及工具、各大公司内部里大牛分享技术文档 PDF 或者 PPT、自然...
  • JUC线程池和Spring提供线程池,jdk 1.8 中日期时间API,数据结构中 图实现及操作和广度优先遍历/深度优先遍历(其他待完善),生成XML文件工具,防止XSS漏洞攻击解决办法,mybatis逆向工程,接口并发测试,BIO...
  • B) 对系统的数据结构进行描述 C) 对目标系统的层次结构进行描述 D) 作为分析和设计的工具 8. 数据字典是数据流图中所有元素的定义的集合,一般由以下四类条目组成(C)。 A) 数据说明条目、控制流条目、加工条目...
  • Android 上百实例源码分析以及开源分析 集合打包4

    千次下载 热门讨论 2012-07-10 21:54:03
    RecipeMedicineMapSQLBuilder 接收方医药信息对应的数据库 SQLBuilder 数据库编辑器 根据参数选择不同的编辑方式 含main方法 SubjectSQLBuilder 项目数据库的编辑器 由上分析可以得出,该软件实现了数据库的操作...
  • 今年9月份参加计算机二级考试的同学请转载 作者:天使~之戀 已被分享1次 评论(0) 复制链接 分享 转载 删除 下面的138道题目,在二级考试中命中率极高。...(69) 单个用户使用的数据视图的描述称为(A) 注:P108 A....
  •  本书还提供了dba完成本职工作必备基本uniix、sql、pl/sql和数据建模知识,也给出了许多富有趣味性例子,通过这些实例详细、循序渐进地说明了oracle database 11g数据库各个概念和特性。 作译者  Sam...
  • (18) 与结构化需求分析方法相对应的是______方法。 答:结构化设计 (19) 关系模型的完整性规则是对关系的某种约束条件,包括实体完整性、______和自定义完整性。 答:参照完整性 (20) 数据模型按不同的应用层次...
  •  静态编译后的易语言EXE/DLL之间不能再共享譬如窗口、窗口组件等类似资源,对于已经静态连接到一个EXE/DLL中的支持库,该支持库中的数据或资源将不能再被其它EXE/DLL中所使用的同名支持库访问。这是因为代码被分别...
  • php高级开发教程说明

    2008-11-27 11:39:22
    据,但后来你发现也需要用它接收数值性的数据,通过工作区转换,可以使它能够接收数值性 数据。但后来你又感觉到这个工作区仍旧不能满足需要,这时唯一能做的就是改变数据库接口, 这需要重构提取层并对所有主代码...
  • 同一个公众号可以配置多个@Weixin注解控制器,其中只需要一个有其他4项配置就可以了,如果多个控制器配置了其他4个配置项,如果相对应的配置项值不相同,启动阶段会报错。 不同微信公众号是通过@Weixin的value...
  • 测试培训教材

    2014-04-01 12:10:48
    9. 把QC中的需求字段和需求模版的列名所对应的字母标号进行关联映射。 从Excel导入 选Demo项目,提示错误: 改成用alice_qc用户登录即可! Author全改成Admin 从...
  • 目 录译者序前言第一部分 Access基础第1章 Access 2000新增功能 11.1 Access 2000透视 11.2 用Office Web组件部署数据访问页 21.2.1 Office Web 组件 21.2.2 DAP演示测试. 31.2.3 DAP设计模式 51.3 为Microsoft...

空空如也

空空如也

1 2 3
收藏数 41
精华内容 16
关键字:

编写实体类对应的数据访问接口