MyBatis实战【上】

MyBatis

主要内容

• Mybatis 入门
• Mybatis 的基本使用 J
• ava 日志处理框架
• Mybatis 配置完善
• SqlSession 常用 API
• Mapper 动态代理
• 动态 SQL
• Mybatis 缓存
• Mybatis 多表关联查询
• Mybatis 注解的使用
• Mybatis Generator 工具的使用
• PageHelper 分页插件
• Mybatis 与 Servlet 整合

一、MyBatis入门

1 什么是框架

框架（Framework）是一个框子——指其约束性，也是一个架子——指其支撑性。是一个基本概念上的结构，用于去解决或者处理复杂的问题。框架这个广泛的定义使用的十分流行，尤其在软件概念。

框架( Framework )是构成一类特定软件可复用设计的一组相互协作的类。框架规定了 你的应用的体系结构。它定义了整体结构，类和对象的分割，各部分的主要责任，类和对象 怎么协作，以及控制流程。框架预定义了这些设计参数，以便于应用设计者或实现者能集中 精力于应用本身的特定细节。

如果将开发完成的软件比作是一套已经装修完毕的新房，那框架就好比是一套已经修建 好的毛坯房。用户直接购买毛坯房，建筑质量和户型合理有保证，还省去了自己建造房屋的 时间，一举多得。

在开发过程是使用框架，同样可以保证减少开发时间、降低开发难度，并且还保证设计质量。好比和世界上最优秀的软件工程师是一个项目的，并且他们完成的还是基础、全局的 工作。想想是不是很嗨的一件事情。

框架还有一个作用是约束。莎士比亚说,“一千个观众眼中有一千个哈姆雷特” 即仁者见 仁,智者见智.说每个人都会对作品有不同的理解，每个人对待任何事物都有自己的看法，一 千个人就有可能有一千种不同的看法 1000 人心中有 1000 个哈姆雷特。同样的技术解决同 样的问题会产生不同流程和风格的解决方案，而采用一种框架其实就是限制用户必须使用其 规定的方案来实现，可以降低程序员之间沟通以及日后维护的成本。

总之，框架是一个半成品，已经对基础的代码进行了封装并提供相应的 API，开发者在 使用框架是直接调用封装好的 API 可以省去很多代码编写，从而提高工作效率和开发速度。

使用框架可以带来的好处：

• 重用代码大大增加，软件生产效率和质量也得到了提高；
• 代码结构的规范化，降低程序员之间沟通以及日后维护的成本；
• 知识的积累，可以让那些经验丰富的人员去设计框架和领域构件，而不必限于低层编程；
• 软件设计人员要专注于对领域的了解，使需求分析更充分；
• 允许采用快速原型技术； 有利于在一个项目内多人协同工作；
• 大粒度的重用使得平均开发费用降低，开发速度加快，开发人员减少，维护费用降低， 而参数化框架使得适应性、灵活性增强。

2 什么是 ORM

ORM，Object-Relationl Mapping，对象关系映射，它的作用是在关系型数据库和对 象之间作一个映射处理。

JDBC 的缺点：需要手动的完成面向对象的 Java 语言、面向关系的数据库之间数据的 转换，代码繁琐无技术含量，影响了开发效率。

如图所示，查询是需要手动的将结果集的列数据转换为 Java 对象的属性；而添加操作 时需要手动将 Java 对象的属性转换为数据库表的列字段。

关于面向对象的 Java 语言、面向关系的数据库之间数据的转换必须要做，问题在于这个转换是否可以不由开发者来做？答案是可以的。ORM 框架就是专门来解决这个问题的， 相当于在面向对象语言和关系数据库之间搭建一个桥梁。这样我们在具体的操作数据库的时 候，只要像平时操作对象一样操作它就可以了，ORM 框架会根据映射完成对数据库的操作， 就不需要再去和复杂的 SQL 语句打交道了。

3 MyBatis 简介

MyBatis 本是 Apache 的一个开源项目 iBatis, 2010 年这个项目由 Apache Software Foundation 迁移到了 Google Code，且改名为 MyBatis 。2013 年 11 月迁移到 GitHub。

MyBatis 是一款优秀的持久层框架，它支持定制化 SQL、存储过程以及高级映射。 MyBatis 避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集。MyBatis 可以使 用简单的 XML 或注解来配置和映射原生信息，将接口和 Java 的 POJOs(Plain Ordinary Java Object,普通的 Java 对象)映射成数据库中的记录。

简单的说：MyBatis 是一个半自动 ORM 框架，其本质是对 JDBC 的封装。使用 MyBatis 重点需要程序员编写 SQL 命令，不需要写一行 JDBC 代码。

与 Hibernate 的比较
Hibernate 是一个全自动的 ORM 框架。因为 Hibernate 创建了 Java 对象和数据库表 之间的完整映射，可以完全以面向对象的思想来操作数据库，程序员不需要手写 SQL 语句， 而 MyBatis 中还需要手写 SQL 语句，所以是半自动化的，工作量要大于 Hibernate。

为什么半自动化的 Mybatis 比自动化的 Hibernate 受欢迎?
MyBatis 需要手写 SQL 语句，所以工作量要大于Hibernate。但是也正是由于自定义 SQL 语句，所以其灵活性、可优化性就超过了 Hibernate。

Hibernate 封装了 SQL 语句，由开发者对对象操作，Hibernate 来生成 SQL 语句。虽 然也可以通过映射配置来控制生成的 SQL 语句，但是对于要生成复杂的 SQL 语句，很难实 现，或者实现后导致性能的丢失。

而 MyBatis 将手写 SQL 语句的工作丢给开发者，可以更加精确的定义 SQL，更加灵活， 也便于优化性能。完成同样功能的两条 SQL 语句的性能可能相差十几倍到几十倍，在高并 发、快响应要求下的互联网系统中，对性能的影响更明显。

MyBatis 对存储过程可提供很好的支持。另外 MyBatis 的开发工作量大不意味着学习 成本大。对于新手，学习 Hibernate 时间成本比 Mybatis 大很多，Mybatis 很快就上手了。

总之，因为 MyBatis 具有封装少、映射多样化、支持存储过程、可以进行 SQL 语句优 化等特点，符合互联网高并发、大数据、高性能、高响应的要求，使它取代 Hibernate 成 为了 Java 互联网中首选的持久框架。而对于对性能要求不高的比如内部管理系统、ERP 等 可以使用 Hibernate。

二、 Mybatis 的基本使用

1 Mybatis 的 jar 包下载地址

https://github.com/mybatis/mybatis-3/releases

2 Mybatis 的 jar 包介绍

3 核心 API 介绍

3.1核心 API

• SqlSessionFactoryBuilder
  SqlSessionFactoryBuilder 的作用是使用构建者模式创建 SqlSessionFactory 接口 对象。

• SqlSessionFactory
  SqlSessionFactory 可以被认为是一个数据库连接池，它的作用是创建 SqlSession 接口对象。

• SqlSession
  如果说 SqlSessionFactory 相当于数据库连接池，那么 SqlSession 就相当于一个数 据库连接（Connection 对象），你可以在一个事务里面执行多条 SQL，然后通过它的 commit、rollback 方法提交或者回滚事务。

• Mapper
  映射器。由一个 Java 接口和 XML 文件（或者注解构成），需要给出对应的 SQL 和映 射规则，负责发送 SQL 去执行并返回结果。

3.2核心 API 工作流程

3.3生命周期

• SqlSessionFactoryBuilder：
  该类用来创建 SqlSessionFactory 对象，当 SqlSessionFactory 对象被创建后， SqlSessionFactoryBuilder 就失去了作用，所以它只能存在于创建 SqlSessionFactory 的 方法中，而不要让其长期存在。因此 SqlSessionFactoryBuilder 实例的最佳作用域是方法 作用域。
• SqlSessionFactory:
  SqlSessionFactory 的生命周期存在于整个 MyBatis 的应用之中，所以一旦创建了 SqlSessionFactory，就要长期保存它，直至不再使用 MyBatis 应用，所以可以认为 SqlSessionFactory 的生命周期就等同于 MyBatis 的应用周期。由于 SqlSessionFactory 是 一 个 对 数 据 库 的 连 接 池 ， 所 以 它 占 据 着 数 据 库 的 连 接 资 源 。 如 果 创 建 多 个SqlSessionFactory，那么就存在多个数据库连接池，这样不利于对数据库资源的控制，也 会导致数据库连接资源被消耗光，出现系统宕机等情况，所以尽量避免发生这样的情况。因 此 SqlSessionFactory 是一个单例，让它在应用中被共享。
• SqlSession:
  SqlSession 应该存活在一个业务请求中，处理完整个请求后，应该关闭这条连接，让 它归还给 SqlSessionFactory，否则数据库资源就很快被耗费精光，系统就会瘫痪，所以 用 try…catch…finally… 语句来保证其正确关闭。 所以 SqlSession 的最佳的作用域是请求或方法作用域。
• Mapper:
  由于 SqlSession 的关闭，它的数据库连接资源也会消失，所以它的生命周期应该小 于等于 SqlSession 的生命周期。Mapper 代表的是一个请求中的业务处理，所以它应该 在一个请求中，一旦处理完了相关的业务，就应该废弃它。

4 Mybatis 的配置文件

https://mybatis.org/mybatis-3/zh/configuration.html
在 Mybatis 中配置文件有两种：

• 全局配置文件
• 映射配置文件

4.1全局配置文件

全局配置文件的名称是自定义的，在 JavaProject 项目中需要放到 src 目录下。
全局配置文件的作用是完成一些全局性的配置，如：对 Mybatis 框架的设置、别名设置、 环境设置、指定映射配置文件等相关配置。

 
DOCTYPE configuration 
PUBLIC "-//mybatis.org//DTD Config 3.0//EN" 
"http://mybatis.org/dtd/mybatis-3-config.dtd"> 
<configuration> 

configuration>

4.1.1 properties 标签

Mybatis 配置文件中的属性定义。properties 标签中允许内部定义属性，也可以是外部的 properties 文件定义属性。无论是内部定义还是外部定义，都可以使用${name}获取值。
配置文件中内部定义

<properties> 
	<property name="jdbc.driver" value="com.mysql.jdbc.Driver"/> 
	<property name="jdbc.url" value="jdbc:mysql://localhost:3306/bjsxt"/> 
	<property name="jdbc.username" value="root"/> 
	<property name="jdbc.password" value="root"/> properties>

配置文件中外部定义

<properties resource="db.properties">properties>

4.1.2 settings 标签

setting 标签的配置是配置 MyBatis 框架运行时的一些行为的，例如缓存、延迟加载、 结果集控制、执行器、分页设置、命名规则等一系列控制性参数，其所有的 setting 配置都 放在父标签 settings 标签中。

<settings> 
	<setting name="cacheEnabled" value="true"/> 
	<setting name="lazyLoadingEnabled" value="true"/> 
	<setting name="multipleResultSetsEnabled" value="true"/> 
	<setting name="useColumnLabel" value="true"/> 
	<setting name="useGeneratedKeys" value="false"/>
	<setting name="autoMappingBehavior" value="PARTIAL"/> 
	<setting name="autoMappingUnknownColumnBehavior" value="WARNING"/> 
	<setting name="defaultExecutorType" value="SIMPLE"/> 
	<setting name="defaultStatementTimeout" value="25"/> 
	<setting name="defaultFetchSize" value="100"/> 
	<setting name="safeRowBoundsEnabled" value="false"/> 
	<setting name="mapUnderscoreToCamelCase" value="false"/> 
	<setting name="localCacheScope" value="SESSION"/> 
	<setting name="jdbcTypeForNull" value="OTHER"/> 
	<setting name="lazyLoadTriggerMethods" value="equals,clone,hashCode,toString"/> 
settings>

4.1.3 typeAliases 标签

类型别名可为 Java 类型设置一个缩写名字。

<typeAliases> 
	<typeAlias alias="user" type="com.bjsxt.pojo.User" /> 
typeAliases>

也可以指定一个包名，MyBatis 会在包名下面搜索需要的 Java Bean

<typeAliases> 
	<package name="com.bjsxt.pojo"/> 
typeAliases>

下面是一些为常见的 Java 类型内建的类型别名。它们都是不区分大小写的

4.1.4 environments 标签

MyBatis 可以配置多个环境。这可以帮助你 SQL 映射对应多种数据库等。比如说，想为 开发、测试、发布产品配置不同的环境。

<environments default="development"> 
	<environment id="development"> 
		<transactionManager type="JDBC"/> 
		<dataSource type="POOLED">
			<property name="driver" value="${jdbc.driver}"/> 
			<property name="url" value="${jdbc.url}"/> 
			<property name="username" value="${jdbc.username}"/> 
			<property name="password" value="${jdbc.password}"/> 
		dataSource>
	environment>
		<transactionManager type="JDBC"/> 
		<dataSource type="POOLED"> 
			<property name="driver" value="${jdbc.driver}"/> 
			<property name="url" value="${jdbc.url}"/> <property name="username" value="${jdbc.username}"/> 
			<property name="password" value="${jdbc.password}"/> 
		dataSource> 
	environment> 
environments>		

4.1.4.1 transactionManager 节点

事务处理器。

在 MyBatis 中有两种类型的事务管理器（也就是 type="[JDBC|MANAGED]"）

JDBC ：这个配置直接使用了 JDBC 的提交和回滚设施，它依赖从数据源获得的连接来 管理事务作用域。

MANAGED ：不做事务处理。

4.1.4.2 dataSource 标签

• dataSource 元素使用标准的 JDBC 数据源接口来配置 JDBC 连接对象的资源。
• UNPOOLED：使用直连。
• POOLED：使用池连。
• JNDI ：使用 JNDI 方式连接

4.1.5 mapper 标签

指定映射配置文件
使用相对于类路径指定映射配置文件

<mappers> 
	<mapper resource="com/bjsxt/mapper/UserMapper.xml"/> 
mappers>

使用 filter:///协议指定映射配置文件

<mappers> 
	<mapper url="file:///D:\code\mybatis\src\com\bjsxt\mapper\UserMapper.xml" />
mappers>

指定映射接口

<mappers> 
	<mapper class="com.bjsxt.mapper.UserMapper"/> 
mappers>

通过包名指定映射接口

<mappers> 
	<package name="com.bjsxt.mapper"/> 
mappers>

4.2映射配置文件

映射配置文件主要是用来编写 sql 语句的，结果集的映射关系的指定，以及缓存的一些 配置等等。

 
DOCTYPE mapper 
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" 
"http://mybatis.org/dtd/mybatis-3-mapper.dtd"> 
<mapper namespace="com.bjsxt.mapper.UserMapper"> 

mapper>

4.2.1 resultMap 标签

指定查询结果集与对象的映射关系，是最复杂也是最强大的标签。
id：唯一标识。
type：类的完全名, 或者一个类型别名

<resultMap id="userMapper" type="com.bjsxt.pojo.User"> 
	<id property="userid" column="user_id"/> 
	<result property="username" column="user_name"/> 
resultMap>

4.2.1.1 id 标签

指定主键中的值，用于标识一个结果映射。

4.2.1.2 result 标签

指定非主键中的值，用于标识一个结果映射。

4.2.1.3 association 标签

通常用来映射一对一的关系。

4.2.1.4 collection 标签

通常用来映射一对多的关系。

4.2.2 select 标签

查询语句。

• id：当前查询语句的唯一标识，该属性的值不能重复。
• parameterType：指定参数类型。该属性是可选属性。因为 MyBatis 可以通过类型处理 器（TypeHandler）推断出具体传入语句的参数。
• resultType：期望从这条语句中返回结果的类全名或别名。
• resultMap：使用 resultMap 标签来处理结果集映射。

<select id="selectUser" parameterType="int" resultType="u"> 
	select * from users where userid = #{userid} 
select>

4.2.3 insert 标签

添加语句。

• id：当前添加语句的唯一标识，该属性的值不能重复。
• parameterType：指定参数类型，可以给定别名。该属性是可选属性。

<insert id="insertUser" parameterType="com.bjsxt.pojo.User">
	insert into users values(default ,#{username},#{usersex}) 
insert>

4.2.4 update 标签

更新语句。

• id：当前更新语句的唯一标识，该属性的值不能重复。
• parameterType：指定参数类型，可以给定别名。该属性是可选属性。

<update id="updateUser" parameterType="com.bjsxt.pojo.User"> 
	update users set username=#{username},usersex=#{usersex} where userid =#{userid} 
update>

4.2.5 delete 标签 删除语句。

• id：当前删除语句的唯一标识，该属性的值不能重复。
• parameterType：指定参数类型，可以给定别名。该属性是可选属性。

<delete id="deleteUser" parameterType="int"> 
	delete from users where userid = #{userid} 
delete>

4.2.6 sql 标签

可以用来定义可重用的 SQL 代码片段。通过标签引入该片段。

• id：当前 SQL 片段的唯一标识，该属性的值不能重复。

<sql id="userColumns"> 
	userid,username,usersex 
sql>

<select id="selectUser" parameterType="int" resultType="u"> 
	select <include refid="userColumns"/> from users 
select>

5 Mybatis 的入门案例

5.1搭建环境

5.1.1 创建表

CREATE TABLE `users` ( 
	`userid` int(11) NOT NULL AUTO_INCREMENT, 
	`username` varchar(20) DEFAULT NULL, 
	`usersex` varchar(10) DEFAULT NULL, 
	PRIMARY KEY (`userid`) 
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

5.1.2 添加 DTD 约束文件

在没有联网的情况下，如果让 dtd 约束继续起作用，并且出现标签提示，可以通过引入 本地 dtd 文件来实现。
下 载 dtd ： 在 浏 览 器 中 输 入 dtd 的 网 络 地 址 即 可 实 现 下 载 。 比 如 ： http://mybatis.org/dtd/mybatis-3-config.dtd
将下载的 dtd 拷贝到本地的一个目录下
Idea 操作路径：File—Settings—Languages & Frameworks

其中 URI 复制 dtd 的网络地址即可。File 选择 dtd 文件在本地的地址。OK!

【注】：在 MyBatis 的核心 jar 包中就提供了 mybatis-3-config.dtd

5.1.3 创建项目

5.1.4 添加 jar 包

5.1.5 创建实体

package com.bjsxt.pojo;

public class Users {
    private int userid;
    private String username;
    private String usersex;

    public int getUserid() {
        return userid;
    }

    public void setUserid(int userid) {
        this.userid = userid;
    }

    public String getUsername() {
        return username;
    }

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

    public String getUsersex() {
        return usersex;
    }

    public void setUsersex(String usersex) {
        this.usersex = usersex;
    }
}

5.1.6 创建 properties 文件

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/bjsxt
jdbc.username=root
jdbc.password=root

5.1.7 创建全局配置文件

DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    
    <properties resource="db.properties"/>

   
    <settings>
        <setting name="logImpl" value="SLF4J"/>
    settings>
    
    <typeAliases>
        <typeAlias type="com.bjsxt.pojo.Users" alias="u"/>
        <package name="com.bjsxt.pojo"/>
    typeAliases>
    
    <environments default="development">
        <environment id="development">
           
            <transactionManager type="JDBC">transactionManager>
           
            <dataSource type="POOLED">
                <property name="driver" value="${jdbc.driver}"/>
                <property name="url" value="${jdbc.url}"/>
                <property name="username" value="${jdbc.username}"/>
                <property name="password" value="${jdbc.password}"/>
            dataSource>
        environment>
    environments>

    
    <mappers>
       
        <mapper resource="com/bjsxt/mapper/UsersMapper.xml"/>
    mappers>

configuration>

5.1.8 创建映射配置文件

DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.bjsxt.mapper.UserMapper">

mapper>

5.2查询数据

5.2.1 修改映射配置文件

DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.bjsxt.mapper.UserMapper">

    
    <select id="selectUsersAll" resultType="com.bjsxt.pojo.Users">
         select * from users
    select>
  
mapper>

5.2.2 创建 UsersDao 接口

package com.bjsxt.dao;

import com.bjsxt.pojo.Users;

import java.io.IOException;
import java.util.List;
import java.util.Map;

public interface UsersDao {
    List<Users> selectUsersAll()throws IOException;
  
}

5.2.3 创建 UsersDao 接口实现类

package com.bjsxt.dao.impl;

import com.bjsxt.dao.UsersDao;
import com.bjsxt.pojo.Users;
import com.bjsxt.utils.MybatisUtils;
import org.apache.ibatis.cursor.Cursor;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;

import java.io.IOException;
import java.io.InputStream;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

public class UsersDaoImpl implements UsersDao {
    /**
     * 查询所有用户
     * @return
     */
    @Override
    public List<Users> selectUsersAll()throws IOException {
        //创建SqlSessionFactory对象
        InputStream inputStream = Resources.getResourceAsStream("mybatis-cfg.xml");
        SqlSessionFactory sqlSessionFacotry = new SqlSessionFactoryBuilder().build(inputStream);
        //获取SqlSession对象
        SqlSession sqlSession = sqlSessionFacotry.openSession();
        //通过SqlSession对象下的API完成对数据库的操作
        List<Users> list = sqlSession.selectList("com.bjsxt.mapper.UserMapper.selectUsersAll");
        //关闭SqlSession对象
        sqlSession.close();
        return list;
    }
}

5.2.4 创建测试类

package com.bjsxt.test;

import com.bjsxt.dao.UsersDao;
import com.bjsxt.dao.impl.UsersDaoImpl;
import com.bjsxt.pojo.Users;

import java.io.IOException;
import java.util.List;

public class Test {
    public static void main(String[] args)throws IOException {
        UsersDao usersDao = new UsersDaoImpl();
        List<Users> list =  usersDao.selectUsersAll();
        for(Users users:list){
            System.out.println(users.getUserid()+"\t"+users.getUsername()+"\t"+users.getUsersex());
        }
    }
}

5.3根据用户 Id 查询数据

DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.bjsxt.mapper.UserMapper">

    
    <select id="selectUsersAll" resultType="com.bjsxt.pojo.Users">
         select * from users
    select>
    
    <select id="selectUsersById" parameterType="int" resultType="users">
         select * from users where userid = #{suibian}
    select>
mapper>

5.3.1 修改映射配置文件

package com.bjsxt.dao;

import com.bjsxt.pojo.Users;

import java.io.IOException;
import java.util.List;
import java.util.Map;

public interface UsersDao {
    List<Users> selectUsersAll()throws IOException;
    Users selectUsersById(int userid)throws IOException;
}

5.3.3 修改 UsersDao 接口实现类

package com.bjsxt.dao.impl;

import com.bjsxt.dao.UsersDao;
import com.bjsxt.pojo.Users;
import com.bjsxt.utils.MybatisUtils;
import org.apache.ibatis.cursor.Cursor;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;

import java.io.IOException;
import java.io.InputStream;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

public class UsersDaoImpl implements UsersDao {
    /**
     * 查询所有用户
     * @return
     */
    @Override
    public List<Users> selectUsersAll()throws IOException {
        //创建SqlSessionFactory对象
        InputStream inputStream = Resources.getResourceAsStream("mybatis-cfg.xml");
        SqlSessionFactory sqlSessionFacotry = new SqlSessionFactoryBuilder().build(inputStream);
        //获取SqlSession对象
        SqlSession sqlSession = sqlSessionFacotry.openSession();
        //通过SqlSession对象下的API完成对数据库的操作
        List<Users> list = sqlSession.selectList("com.bjsxt.mapper.UserMapper.selectUsersAll");
        //关闭SqlSession对象
        sqlSession.close();
        return list;
    }

    /**
     *  根据用户ID查询用户
     * @param userid
     * @return
     * @throws IOException
     */
    @Override
    public Users selectUsersById(int userid) throws IOException {
        //创建SqlSessionFactory对象
        InputStream inputStream = Resources.getResourceAsStream("mybatis-cfg.xml");
        SqlSessionFactory sqlSessionFacotry = new SqlSessionFactoryBuilder().build(inputStream);
        //获取SqlSession对象
        SqlSession sqlSession = sqlSessionFacotry.openSession();
        Users users = sqlSession.selectOne("com.bjsxt.mapper.UserMapper.selectUsersById",userid);
        sqlSession.close();
        return users;
    }
}

5.3.4 修改测试类

package com.bjsxt.test;

import com.bjsxt.dao.UsersDao;
import com.bjsxt.dao.impl.UsersDaoImpl;
import com.bjsxt.pojo.Users;

import java.io.IOException;
import java.util.List;

public class Test {
    public static void main(String[] args)throws IOException {
        UsersDao usersDao = new UsersDaoImpl();
        /*List list =  usersDao.selectUsersAll();
        for(Users users:list){
            System.out.println(users.getUserid()+"\t"+users.getUsername()+"\t"+users.getUsersex());
        }*/
        Users users = usersDao.selectUsersById(1);
        System.out.println(users.getUserid()+"\t"+users.getUsername()+"\t"+users.getUsersex());
    }
}

5.4Mybatis 中的参数绑定

在映射配置文件中向 SQL 语句中绑定参数的语法结构为#{ }和${ }。
#{ } 和 ${ }的区别：
#{ } 解析为一个 JDBC 预编译语句（PreparedStatement）的参数标记符占位符 ？。使 用该方式可避免 SQL 注入。
${ }仅仅为一个纯碎的 String 替换，在 Mybatis 的动态 SQL 解析阶段将会进行变量替 换。${ }在预编译之前已经被变量替换了，这会存在 SQL 注入问题。

5.5创建 Mybatis 的工具类

5.5.1 ThreadLocal 介绍

ThreadLocal 提供了线程内存储变量的能力，这些变量不同之处在于每一个线程读取的 变量是对应的互相独立的。通过get和set 方法就可以得到当前线程对应的值。

5.5.2 使用 ThreadLocal 存储 SqlSession

如果多个 DML 操作属于一个事务，因为 commit()和 rollback()都是由 SqlSession 完成的， 所以必须保证使用一个 SqlSession。但是多个不同的 DML 操作可能在不同类的不同方法中， 每个方法中要单独的获取 SqlSession。比如商城下订单时，其实涉及商品库存变化、订单添 加、订单明细添加、付款、日志添加等多个 DML 操作，分布在不同类中。
如何在多个 DML 操作之间使用同一个 SqlSession 呢，可以使用 ThreadLocal 来存储。保 证一个线程中的操作使用的都是一个 SqlSession。

在 Web 项目中用户的每次请求会启动一个新的线程，比如点击”结算”完成购物车结 算。在 Java 项目中每次启动 main()也会自动开启一个 main 线程

5.5.3 创建 Mybatis 工具类

package com.bjsxt.utils;

import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;

import java.io.IOException;
import java.io.InputStream;

public class MybatisUtils {
    private static ThreadLocal<SqlSession> threadLocal = new ThreadLocal<>();
    private static SqlSessionFactory sqlSessionFactory = null;
    static{
        //创建SqlSessionFactory
        InputStream is = null;
        try{
            is = Resources.getResourceAsStream("mybatis-cfg.xml");
        }catch (IOException e){
            e.printStackTrace();
        }
        sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
    }

    //获取SqlSession
    public static SqlSession getSqlSession(){
        SqlSession sqlSession = threadLocal.get();
        if(sqlSession == null){
            sqlSession = sqlSessionFactory.openSession();
            threadLocal.set(sqlSession);
        }
        return sqlSession;
    }

    //关闭SqlSession
    public static void closeSqlSession(){
        SqlSession sqlSession = threadLocal.get();
        if(sqlSession != null){
            sqlSession.close();
            threadLocal.set(null);
        }
    }
}

5.6完成 DML 操作

5.6.1 Mybatis 的事务提交方式

在 Mybatis 中事务提交方式默认为手动提交，这与 JDBC 是不同的。在 JDBC 中事务默认 提交方式为自动提交。
手动提交事务(默认)

SqlSession sqlSession = sqlSessionFacotry.openSession();

自动提交事务

SqlSession sqlSession = sqlSessionFacotry.openSession(true);

5.6.2 添加用户操作

5.6.2.1 修改映射配置文件

DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.bjsxt.mapper.UserMapper">

    
    <select id="selectUsersAll" resultType="com.bjsxt.pojo.Users">
         select * from users
    select>
    
    <select id="selectUsersById" parameterType="int" resultType="users">
         select * from users where userid = #{suibian}
    select>

    
    <insert id="insertUsers" >
        insert into users value(default ,#{username},#{usersex})
    insert>
mapper>

5.6.2.2 修改 UsersDao 接口

package com.bjsxt.dao;

import com.bjsxt.pojo.Users;

import java.io.IOException;
import java.util.List;
import java.util.Map;

public interface UsersDao {
    List<Users> selectUsersAll()throws IOException;
    Users selectUsersById(int userid)throws IOException;
    void insertUsers(Users users);
}

5.6.2.3 修改 UsersDao 接口实现类

package com.bjsxt.dao.impl;

import com.bjsxt.dao.UsersDao;
import com.bjsxt.pojo.Users;
import com.bjsxt.utils.MybatisUtils;
import org.apache.ibatis.cursor.Cursor;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;

import java.io.IOException;
import java.io.InputStream;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

public class UsersDaoImpl implements UsersDao {
    /**
     * 查询所有用户
     * @return
     */
    @Override
    public List<Users> selectUsersAll()throws IOException {
        //创建SqlSessionFactory对象
        InputStream inputStream = Resources.getResourceAsStream("mybatis-cfg.xml");
        SqlSessionFactory sqlSessionFacotry = new SqlSessionFactoryBuilder().build(inputStream);
        //获取SqlSession对象
        SqlSession sqlSession = sqlSessionFacotry.openSession();
        //通过SqlSession对象下的API完成对数据库的操作
        List<Users> list = sqlSession.selectList("com.bjsxt.mapper.UserMapper.selectUsersAll");
        //关闭SqlSession对象
        sqlSession.close();
        return list;
    }

    /**
     *  根据用户ID查询用户
     * @param userid
     * @return
     * @throws IOException
     */
    @Override
    public Users selectUsersById(int userid) throws IOException {
        //创建SqlSessionFactory对象
        InputStream inputStream = Resources.getResourceAsStream("mybatis-cfg.xml");
        SqlSessionFactory sqlSessionFacotry = new SqlSessionFactoryBuilder().build(inputStream);
        //获取SqlSession对象
        SqlSession sqlSession = sqlSessionFacotry.openSession();
        Users users = sqlSession.selectOne("com.bjsxt.mapper.UserMapper.selectUsersById",userid);
        sqlSession.close();
        return users;
    }

    @Override
    public void insertUsers(Users users) {
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        sqlSession.insert("com.bjsxt.mapper.UserMapper.insertUsers", users);
    }
}

5.6.2.4 创建 UsersService 业务层接口

package com.bjsxt.service;

import com.bjsxt.pojo.Users;

import java.util.Map;

public interface UsersService {
    void addUsers(Users users);
}

5.6.2.5 创建 UsersService 业务层接口实现类

package com.bjsxt.service.impl;

import com.bjsxt.dao.UsersDao;
import com.bjsxt.dao.impl.UsersDaoImpl;
import com.bjsxt.pojo.Users;
import com.bjsxt.service.UsersService;
import com.bjsxt.utils.MybatisUtils;
import org.apache.ibatis.session.SqlSession;

import java.util.Map;

public class UsersServiceImpl implements UsersService {
    /**
     * 添加用户
     * @param users
     */
    @Override
    public void addUsers(Users users) {
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        try{
            UsersDao usersDao =  new UsersDaoImpl();
            usersDao.insertUsers(users);
            sqlSession.commit();
        }catch (Exception e){
            e.printStackTrace();
            sqlSession.rollback();
        }finally{
            MybatisUtils.closeSqlSession();
        }
    }
}

5.6.2.6 创建测试类

package com.bjsxt.test;

import com.bjsxt.pojo.Users;
import com.bjsxt.service.UsersService;
import com.bjsxt.service.impl.UsersServiceImpl;

public class AddUserTest {
    public static void main(String[] args) {
        UsersService usersService = new UsersServiceImpl();
        Users users = new Users();
        users.setUsername("zhangsan");
        users.setUsersex("male");
        usersService.addUsers(users);
    }
}

5.6.3 更新用户操作

5.6.3.1 修改映射配置文件

DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.bjsxt.mapper.UserMapper">

    
    <select id="selectUsersAll" resultType="com.bjsxt.pojo.Users">
         select * from users
    select>
    
    <select id="selectUsersById" parameterType="int" resultType="users">
         select * from users where userid = #{suibian}
    select>

    
    <insert id="insertUsers" >
        insert into users value(default ,#{username},#{usersex})
    insert>

    
    <select id="selectUserById2" resultType="com.bjsxt.pojo.Users">
        select * from users where userid = ${userid}
    select>
mapper>

5.6.3.2 修改 UsersDao 接口

package com.bjsxt.dao;

import com.bjsxt.pojo.Users;

import java.io.IOException;
import java.util.List;
import java.util.Map;

public interface UsersDao {
    List<Users> selectUsersAll()throws IOException;
    Users selectUsersById(int userid)throws IOException;
    void insertUsers(Users users);
    Users selectUsersById2(int userid);
    void updateUsersById(Users users);
}

5.6.3.3 修改 UsersDao 接口实现类

package com.bjsxt.dao.impl;

import com.bjsxt.dao.UsersDao;
import com.bjsxt.pojo.Users;
import com.bjsxt.utils.MybatisUtils;
import org.apache.ibatis.cursor.Cursor;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;

import java.io.IOException;
import java.io.InputStream;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

public class UsersDaoImpl implements UsersDao {
    /**
     * 查询所有用户
     * @return
     */
    @Override
    public List<Users> selectUsersAll()throws IOException {
        //创建SqlSessionFactory对象
        InputStream inputStream = Resources.getResourceAsStream("mybatis-cfg.xml");
        SqlSessionFactory sqlSessionFacotry = new SqlSessionFactoryBuilder().build(inputStream);
        //获取SqlSession对象
        SqlSession sqlSession = sqlSessionFacotry.openSession();
        //通过SqlSession对象下的API完成对数据库的操作
        List<Users> list = sqlSession.selectList("com.bjsxt.mapper.UserMapper.selectUsersAll");
        //关闭SqlSession对象
        sqlSession.close();
        return list;
    }

    /**
     *  根据用户ID查询用户
     * @param userid
     * @return
     * @throws IOException
     */
    @Override
    public Users selectUsersById(int userid) throws IOException {
        //创建SqlSessionFactory对象
        InputStream inputStream = Resources.getResourceAsStream("mybatis-cfg.xml");
        SqlSessionFactory sqlSessionFacotry = new SqlSessionFactoryBuilder().build(inputStream);
        //获取SqlSession对象
        SqlSession sqlSession = sqlSessionFacotry.openSession();
        Users users = sqlSession.selectOne("com.bjsxt.mapper.UserMapper.selectUsersById",userid);
        sqlSession.close();
        return users;
    }

    @Override
    public void insertUsers(Users users) {
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        sqlSession.insert("com.bjsxt.mapper.UserMapper.insertUsers", users);
    }

    //预更新用户的查询
    @Override
    public Users selectUsersById2(int userid) {
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        Users users =  sqlSession.selectOne("com.bjsxt.mapper.UserMapper.selectUserById2",userid);
        return users;
    }

    //更新用户
    @Override
    public void updateUsersById(Users users) {
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        sqlSession.update("com.bjsxt.mapper.UserMapper.updateUsersById", users);
    }
}

5.6.3.4 修改 UsersService 接口

package com.bjsxt.service;

import com.bjsxt.pojo.Users;

import java.util.Map;

public interface UsersService {
    void addUsers(Users users);
    Users preUpdateUsers(int userid);
    void modifyUsers(Users users);
}

5.6.3.5 修改 UsersService 接口实现类

package com.bjsxt.service.impl;

import com.bjsxt.dao.UsersDao;
import com.bjsxt.dao.impl.UsersDaoImpl;
import com.bjsxt.pojo.Users;
import com.bjsxt.service.UsersService;
import com.bjsxt.utils.MybatisUtils;
import org.apache.ibatis.session.SqlSession;

import java.util.Map;

public class UsersServiceImpl implements UsersService {
    /**
     * 添加用户
     * @param users
     */
    @Override
    public void addUsers(Users users) {
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        try{
            UsersDao usersDao =  new UsersDaoImpl();
            usersDao.insertUsers(users);
            sqlSession.commit();
        }catch (Exception e){
            e.printStackTrace();
            sqlSession.rollback();
        }finally{
            MybatisUtils.closeSqlSession();
        }
    }

    @Override
    public Users preUpdateUsers(int userid) {
        Users users = null;
        try{
            SqlSession sqlSession = MybatisUtils.getSqlSession();
           UsersDao usersDao = new UsersDaoImpl();
           users = usersDao.selectUsersById2(userid);
        }catch(Exception e){
            e.printStackTrace();
        }finally {
            MybatisUtils.closeSqlSession();
        }
        return users;
    }

    @Override
    public void modifyUsers(Users users) {
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        try{
            UsersDao usersDao = new UsersDaoImpl();
            usersDao.updateUsersById(users);
            sqlSession.commit();
        }catch(Exception e){
            e.printStackTrace();
            sqlSession.rollback();
        }finally {
            MybatisUtils.closeSqlSession();
        }
    }
}

5.6.3.6 创建测试类

package com.bjsxt.test;

import com.bjsxt.pojo.Users;
import com.bjsxt.service.UsersService;
import com.bjsxt.service.impl.UsersServiceImpl;

public class UpdateUsersTest {
    public static void main(String[] args) {
        UsersService usersService = new UsersServiceImpl();
        Users users = usersService.preUpdateUsers(2);
        System.out.println(users.getUserid());
        users.setUsername("OLDLU");
        users.setUsersex("MALE");
        usersService.modifyUsers(users);
    }
}

5.6.4 删除用户操作

5.6.4.1 修改映射配置文件

DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.bjsxt.mapper.UserMapper">

    
    <select id="selectUsersAll" resultType="com.bjsxt.pojo.Users">
         select * from users
    select>
    
    <select id="selectUsersById" parameterType="int" resultType="users">
         select * from users where userid = #{suibian}
    select>

    
    <insert id="insertUsers" >
        insert into users value(default ,#{username},#{usersex})
    insert>

    
    <select id="selectUserById2" resultType="com.bjsxt.pojo.Users">
        select * from users where userid = ${userid}
    select>
    
    <update id="updateUsersById" >
        update users set username = #{username},usersex=#{usersex} where userid = #{userid}
    update>
   
    <delete id="deleteUsersById">
        delete from users where userid = #{userid}
    delete>
mapper>

5.6.4.2 修改 UsersDao 接口

package com.bjsxt.dao;

import com.bjsxt.pojo.Users;

import java.io.IOException;
import java.util.List;
import java.util.Map;

public interface UsersDao {
    List<Users> selectUsersAll()throws IOException;
    Users selectUsersById(int userid)throws IOException;
    void insertUsers(Users users);
    Users selectUsersById2(int userid);
    void updateUsersById(Users users);
    void deleteUsersById(int userid);
}

5.6.4.3 修改 UsersDao 接口实现类

package com.bjsxt.dao.impl;

import com.bjsxt.dao.UsersDao;
import com.bjsxt.pojo.Users;
import com.bjsxt.utils.MybatisUtils;
import org.apache.ibatis.cursor.Cursor;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;

import java.io.IOException;
import java.io.InputStream;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

public class UsersDaoImpl implements UsersDao {
    /**
     * 查询所有用户
     * @return
     */
    @Override
    public List<Users> selectUsersAll()throws IOException {
        //创建SqlSessionFactory对象
        InputStream inputStream = Resources.getResourceAsStream("mybatis-cfg.xml");
        SqlSessionFactory sqlSessionFacotry = new SqlSessionFactoryBuilder().build(inputStream);
        //获取SqlSession对象
        SqlSession sqlSession = sqlSessionFacotry.openSession();
        //通过SqlSession对象下的API完成对数据库的操作
        List<Users> list = sqlSession.selectList("com.bjsxt.mapper.UserMapper.selectUsersAll");
        //关闭SqlSession对象
        sqlSession.close();
        return list;
    }

    /**
     *  根据用户ID查询用户
     * @param userid
     * @return
     * @throws IOException
     */
    @Override
    public Users selectUsersById(int userid) throws IOException {
        //创建SqlSessionFactory对象
        InputStream inputStream = Resources.getResourceAsStream("mybatis-cfg.xml");
        SqlSessionFactory sqlSessionFacotry = new SqlSessionFactoryBuilder().build(inputStream);
        //获取SqlSession对象
        SqlSession sqlSession = sqlSessionFacotry.openSession();
        Users users = sqlSession.selectOne("com.bjsxt.mapper.UserMapper.selectUsersById",userid);
        sqlSession.close();
        return users;
    }

    @Override
    public void insertUsers(Users users) {
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        sqlSession.insert("com.bjsxt.mapper.UserMapper.insertUsers", users);
    }

    //预更新用户的查询
    @Override
    public Users selectUsersById2(int userid) {
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        Users users =  sqlSession.selectOne("com.bjsxt.mapper.UserMapper.selectUserById2",userid);
        return users;
    }

    //更新用户
    @Override
    public void updateUsersById(Users users) {
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        sqlSession.update("com.bjsxt.mapper.UserMapper.updateUsersById", users);
    }

    @Override
    public void deleteUsersById(int userid) {
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        final int delete = sqlSession.delete("com.bjsxt.mapper.UserMapper.deleteUsersById", userid);
    }
 }

5.6.4.4 修改 UsersService 接口

package com.bjsxt.service;

import com.bjsxt.pojo.Users;

import java.util.Map;

public interface UsersService {
    void addUsers(Users users);
    Users preUpdateUsers(int userid);
    void modifyUsers(Users users);
    void dropUsersById(int userid);
}

5.6.4.5 修改 UsersService 接口实现类

package com.bjsxt.service.impl;

import com.bjsxt.dao.UsersDao;
import com.bjsxt.dao.impl.UsersDaoImpl;
import com.bjsxt.pojo.Users;
import com.bjsxt.service.UsersService;
import com.bjsxt.utils.MybatisUtils;
import org.apache.ibatis.session.SqlSession;

import java.util.Map;

public class UsersServiceImpl implements UsersService {
    /**
     * 添加用户
     * @param users
     */
    @Override
    public void addUsers(Users users) {
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        try{
            UsersDao usersDao =  new UsersDaoImpl();
            usersDao.insertUsers(users);
            sqlSession.commit();
        }catch (Exception e){
            e.printStackTrace();
            sqlSession.rollback();
        }finally{
            MybatisUtils.closeSqlSession();
        }
    }

    @Override
    public Users preUpdateUsers(int userid) {
        Users users = null;
        try{
            SqlSession sqlSession = MybatisUtils.getSqlSession();
           UsersDao usersDao = new UsersDaoImpl();
           users = usersDao.selectUsersById2(userid);
        }catch(Exception e){
            e.printStackTrace();
        }finally {
            MybatisUtils.closeSqlSession();
        }
        return users;
    }

    @Override
    public void modifyUsers(Users users) {
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        try{
            UsersDao usersDao = new UsersDaoImpl();
            usersDao.updateUsersById(users);
            sqlSession.commit();
        }catch(Exception e){
            e.printStackTrace();
            sqlSession.rollback();
        }finally {
            MybatisUtils.closeSqlSession();
        }
    }

    @Override
    public void dropUsersById(int userid) {
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        try{
            UsersDao usersDao = new UsersDaoImpl();
            usersDao.deleteUsersById(userid);
            sqlSession.commit();
        }catch(Exception e){
            e.printStackTrace();
            sqlSession.rollback();
        }finally{
            MybatisUtils.closeSqlSession();
        }
    }
}

5.6.4.6 创建测试类

package com.bjsxt.test;

import com.bjsxt.service.UsersService;
import com.bjsxt.service.impl.UsersServiceImpl;

public class DeleteUsersTest {
    public static void main(String[] args) {
        UsersService usersService = new UsersServiceImpl();
        usersService.dropUsersById(3);
    }
}

三、 Java 日志处理框架

1 常用的日志处理框架

对于一个应用程序来说日志记录是必不可少的一部分。线上问题追踪，错误排查，基于 日志的业务逻辑统计分析等都离不日志。
日志的管理是系统很重要的一部分，千万不可忽略其重要性。完整的日志将会在系统维 护中起着异常重要的作用。
在 Java 领域存在多种日志框架，目前常用的日志框架包括 Log4j，Log4j2，Commons Logging，Slf4j，Logback，Jul。

2 Log4j 简介

Log4j： Log For Java(Java 的日志) 是 Apache 提供的一个开源的 Java 主流的日志框架。

3 Log4j 的日志级别

Log4j 定义了 8 个日志级别（除去 OFF 和 ALL，可以说分为 6 个级别），优先级从高到 低依次为：OFF、FATAL、ERROR、WARN、INFO、DEBUG、TRACE、 ALL。

在 Log4j 中建议只使用 DEBUG、INFO、WARN、ERROR 四个日志级别。

• ALL 最低等级的，用于打开所有日志记录。
• TRACE designates finer-grained informational events than the DEBUG.Since:1.2.12，很低的 日志级别，一般不会使用。
• DEBUG 指出细粒度信息事件对调试应用程序是非常有帮助的，主要用于开发过程中打 印一些运行信息。
• INFO 消息在粗粒度级别上突出强调应用程序的运行过程。打印一些你感兴趣的或者重 要的信息，这个可以用于生产环境中输出程序运行的一些重要信息，但是不能滥用，避 免打印过多的日志。
• WARN 表明会出现潜在错误的情形，有些信息不是错误信息，但是也要给程序员的一 些提示。
• ERROR 指出虽然发生错误事件，但仍然不影响系统的继续运行。打印错误和异常信息， 如果不想输出太多的日志，可以使用这个级别。
• FATAL 指出每个严重的错误事件将会导致应用程序的退出。这个级别比较高了。重大错 误，这种级别你可以直接停止程序了。
• OFF 最高等级的，用于关闭所有日志记录。

4 Log4j 的使用

4.1Log4j 配置文件详解

4.1.1 Log4j 配置文件名

log4j 配置文件名：log4j.properties
Log4j 配值文件存放位置：项目的 src 的根目录中

4.1.2 配置根 Logger

log4j.rootLogger = [level],appenderName,appenderName2,...

level 是日志记录的优先级，优先级从低到高分别是 DEBUG,INFO,WARN,ERROR。通过在 这里定义的级别，您可以控制到应用程序中相应级别的日志信息的开关，比如在这里定义了 INFO 级别，则应用程序中所有 DEBUG 级别的日志信息将不被打印出来

appenderName 就是指定日志信息输出到哪个地方。可同时指定多个输出目的地。

4.1.3 Log4j 中的 appender

• org.apache.log4j.ConsoleAppender(输出到控制台)
• org.apache.log4j.FileAppender(输出到文件)
• org.apache.log4j.DailyRollingFileAppender(每天产生一个日志文件)
• org.apache.log4j.RollingFileAppender(文件大小到达指定尺寸的时候产生一个新的文件)
• org.apache.log4j.WriterAppender(将日志信息以流格式发送到任意指定的地方)
• org.apache.log4j.jdbc.JDBCAppender(将日志信息添加数据库中)

4.1.4 向控制台输出的 appender

### appender.console 输出到控制台 ### 
log4j.appender.console=org.apache.log4j.ConsoleAppender
log4j.appender.console.layout=org.apache.log4j.PatternLayout 
log4j.appender.console.layout.ConversionPattern=<%d> %5p (%F:%L) [%t] (%c) - %m%n 
log4j.appender.console.Target=System.out

4.1.5 向文件输出的 appender

### appender.logfile 输出到日志文件 ### 
log4j.appender.logfile=org.apache.log4j.RollingFileAppender 
log4j.appender.logfile.File=SysLog.log 
log4j.appender.logfile.MaxFileSize=500KB 
log4j.appender.logfile.MaxBackupIndex=7 
log4j.appender.logfile.layout=org.apache.log4j.PatternLayout 
log4j.appender.logfile.layout.ConversionPattern=<%d> %p (%F:%L) [%t] %c - %m%n

4.1.6 向数据库输出的 appender

log4j.appender.logDB=org.apache.log4j.jdbc.JDBCAppender 
log4j.appender.logDB.layout=org.apache.log4j.PatternLayout 
log4j.appender.logDB.Driver=com.mysql.jdbc.Driver 
log4j.appender.logDB.URL=jdbc:mysql://localhost:3306/bjsxt 
log4j.appender.logDB.User=root 
log4j.appender.logDB.Password=root 
log4j.appender.logDB.Sql=INSERT INTO 
logs(project_name,create_date,level,category,file_name,thread_name,line,all_ category,message)values('logDemo','%d{yyyy-MM-ddHH:mm:ss}','%p','%c','%F','% t','%L','%l','%m')

4.1.7 通过包名控制日志输出级别

log4j.logger.org.apache=FATAL 
log4j.logger.org.apache.commons=ERROR 
log4j.logger.org.springframework=ERROR 
log4j.logger.com.bjsxt=ERROR

4.1.8 Log4j 的输出格式

Log4J 采用类似 C 语言中的 printf 函数的打印格式格式化日志信息，打印参数如下：

• %m 输出代码中指定的消息
• %p 输出优先级，即 DEBUG,INFO,WARN,ERROR,FATAL
• %r 输出自应用启动到输出该 log 信息耗费的毫秒数
• %c 输出所属的类目,通常就是所在类的全名
• %t 输出产生该日志事件的线程名
• %n 输出一个回车换行符，Windows 平台为“\r\n”，Unix 平台为“\n”
• %d 输出日志时间点的日期或时间，默认格式为 ISO8601，也可以在其后指定格式
  如：%d{yyyy 年 MM 月 dd 日 HH:mm:ss,SSS}，输出类似：2020 年 05 月 01 日 22:10:28,921
• %l输出日志事件的发生位置，包括类目名、发生的线程，以及在代码中的行数 如： Testlog.main(TestLog.java:10)
• %F 输出日志消息产生时所在的文件名称
• %L 输出代码中的行号
• %x 输出和当前线程相关联的 NDC(嵌套诊断环境),像 java servlets 多客户多线程的应用 中
• %%输出一个"%"字符

可以在%与模式字符之间加上修饰符来控制其最小宽度、最大宽度、和文本的对齐方式。 如：

• %5c: 输出 category 名称，最小宽度是 5，category<5，默认的情况下右对齐
• %-5c:输出 category 名称，最小宽度是 5，category<5，"-"号指定左对齐,会有空格
• %.5c:输出 category 名称，最大宽度是 5，category>5，就会将左边多出的字符截掉，<5 不会有空格
• %20.30c:category 名称<20 补空格，并且右对齐，>30 字符，就从左边交远销出的字符截掉

4.2Log4j 的使用方式

4.2.1 Log4j.jar

添加 jar 包：log4j.jar
添加配置文件：log4j.properties
通过 Log4j 的 API 完成日志

import org.apache.log4j.Logger; 
public class LogDemo { 
	private final static Logger logger = Logger.getLogger(LogDemo.class); 
}

4.2.2 commons-logging + log4j

commons-logging 是 Apache 的 Commons 项目中提供的一个高层的日志框架，是门面模 式的典型应用。commons-logging 本身没有实现真正的日志能力。它可以挂接不同的日志系 统，默认情况下，Commons Loggin 自动搜索并使用 Log4j，如果没有找到 Log4j，再使用JDK。

Logging。
log4j.jar
commons-loggin.jar
项目中常用使用

import org.apache.commons.logging.Log; 
import org.apache.commons.logging.LogFactory; 
public class LogDemo { 
	private static final Log logger = LogFactory.getLog(LogDemo.class); 
	}

4.2.3 slf4j-api + slf4j-log4j + log4j

SLF4J 的全称是 Simple Logging Facade for Java，即简单日志门面应用。SLF4J 并不是具体 的日志框架，而是作为一个简单门面服务于各类日志框架，如 java.util.logging, logback 和 log4j。
slf4j-api.jar
slf4j-log4j.jar
log4j.jar

import org.slf4j.Logger; 
import org.slf4j.LoggerFactory; 
public class LogDemo { 
	private static final Logger logger = LoggerFactory.getLogger(LogDemo.class); 
}

四、 Mybatis 配置的完善

1 Mybatis 的日志管理

Mybatis 的内置日志工厂（LogFactory）提供日志处理功能，内置日志工厂将日志交 给以下其中一种工具作代理：

• SLF4J
• Apache Commons Logging
• Log4j2
• Log4j
• JDK logging
• NO_LOGGING
  MyBatis 内置日志工厂基于运行时自省机制选择合适的日志工具。它会使用第一个查 找得到的工具（按上文列举的顺序查找）。如果一个都未找到，日志功能就会被禁用。也就是说在项目中把日志工具环境配置出来后，不用再 MyBatis 进行配置就可以让日志生效。
  

指定 SLF4J 作为日志处理器

<settings> 
	<setting name="logImpl" value="SLF4J"/> 
settings>

2 使用别名 alias

Mybatis 中的别名配置它只和 XML 配置有关, 只用来减少类完全限定名的多余部分。注 意：别名都是大小写不敏感的。
在配置文件中为类的完整路径定义别名，可以采用两种方式

2.1方式一

使用 typeAlias 指定单个类的别名,在全局配置文件中配置，【注意】：直接放到setting标签之后

DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    
    <properties resource="db.properties"/>

   
    <settings>
        <setting name="logImpl" value="SLF4J"/>
    settings>
    
    <typeAliases>
        <typeAlias type="com.bjsxt.pojo.Users" alias="u"/>
        <package name="com.bjsxt.pojo"/>
    typeAliases>
    
    <environments default="development">
        <environment id="development">
           
            <transactionManager type="JDBC">transactionManager>
           
            <dataSource type="POOLED">
                <property name="driver" value="${jdbc.driver}"/>
                <property name="url" value="${jdbc.url}"/>
                <property name="username" value="${jdbc.username}"/>
                <property name="password" value="${jdbc.password}"/>
            dataSource>
        environment>
    environments>

    
    <mappers>
       
        <mapper resource="com/bjsxt/mapper/UsersMapper.xml"/>
    mappers>


configuration>

<select id="selectUsersById" parameterType="int" resultType="u"> 
	select * from users where userid = #{suibian} 
select>

2.2方式二

使用 package 指定某个包下所有类的默认别名

<typeAliases> 
	<package name="com.bjsxt.pojo"/> 
typeAliases>

引入别名后的映射文件 <select id="selectUsersById" parameterType="int" resultType="users"> select * from users where userid = #{suibian} select>

五、 SqlSession 对象下的常用 API

SqlSession 对象下的方法是用来执行定义在映射配置文件中的 SELECT，INSERT，UPDATE 和 DELETE 语句。通过 SqlSession 对象下的 API 向 SQL 语句传递参数时，参数可以是基本数 据类型、包装类类型 ,POJO 或 Map。但是参数的数量只能是一个。

SqlSession 对象下的方法需要 namespace + id 来定位需要执行的 SQL 语句。

namespace + id 的作用: 即：namespace 定位到唯一的 mapper 映射文件，id 定位到这 个 mapper 映射文件的指定的 sql 语句。

1 查询操作

1.1selectOne 方法

T selectOne(String namespace + id , Object parameter)

1.2selectList 方法

List selectList(String namespace + id , Object parameter)

1.3selectMap 方法

Map selectMap(String namespace + id , Object parameter, String mapKey)

    <select id="selectUsersByNameAndSex" resultType="u">
        select * from users where username =#{name} and usersex = #{sex}
    select>

UserDao

 Map<Integer,Users> selectUserByNameAndSex(String  username,String usersex);

UsersDaoImpl

@Override
    public Map<Integer, Users> selectUserByNameAndSex(String username, String usersex) {
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        Map<String,String> param = new HashMap<>();
        param.put("name",username);
        param.put("sex",usersex);
        Map<Integer, Users> users = sqlSession.selectMap("com.bjsxt.mapper.UserMapper.selectUsersByNameAndSex", param, "userid");
        return users;
    }

UsersService

 Map<Integer,Users> findUsersByNameAndSex(String username,String usersex);

UsersSecviceImpl

 @Override
    public Map<Integer, Users> findUsersByNameAndSex(String username, String usersex) {
        Map<Integer, Users> map = null;
        try{
            UsersDao usersDao = new UsersDaoImpl();
            map = usersDao.selectUserByNameAndSex(username,usersex);
        }catch(Exception e){
            e.printStackTrace();
        }finally{
            MybatisUtils.closeSqlSession();
        }

        return map;
    }

Test

package com.bjsxt.test;

import com.bjsxt.pojo.Users;
import com.bjsxt.service.UsersService;
import com.bjsxt.service.impl.UsersServiceImpl;

import java.util.Map;
import java.util.Set;

public class SelectMapTest {
    public static void main(String[] args) {
        UsersService usersService = new UsersServiceImpl();
        Map<Integer, Users> map = usersService.findUsersByNameAndSex("bjsxt", "male");
        Set<Integer> integers = map.keySet();
        for(Integer key:integers){
            Users users = map.get(key);
            System.out.println(key);
            System.out.println(users.getUserid()+"\t"+users.getUsername()+"\t"+users.getUsersex());
        }
    }
}

2 DML 操作

2.1 insert 方法

int insert(String statement, Object parameter)

2.2 update 方法

int update(String statement, Object parameter)

2.3 delete 方法

int delete(String statement, Object parameter)

六、 Mapper 动态代理

1 基于 Mybatis 的 Dao 层设计

在 Mybatis 中对于 Dao 层的设计提供了两种方式：

1.1 Dao 层不使用 Mapper 动态代理

所谓不使用动态代理是指在 Dao 层需要我们自己来创建 Dao 层的接口与接口实现类。 在接口实现类的方法中我们自己通过调用 SqlSession 对象的方法完成数据库的操作。
目前我们的入门案例就是通过这种方式完成了对 users 表的 CRUD 操作。

Dao 层不使用 Mapper 动态代理缺点：

1.在 SqlSession 对象的常用方法中只能向 SQL 语句中传递一个参数。如果要多个参数， 需要封装到 POJO 或者 Map 中。

2.调用 SqlSession 对象的方法时会有硬编码现象 namespace + id。

1.2 Dao 层使用 Mapper 动态代理

在 MyBatis 中提供了另外一种 Dao 层的实现方式，既：Mapper 动态代理（或称为接口 绑定）的操作方式。这种方式下程序员只需要写 Dao 接口，不需要创建 Dao 的接口实现类， Mybatis 会自动生成接口实现类的代理对象。在 Dao 层我们只要创建接口与映射配置文件即 可。这种方式可以大大简化 Dao 层的代码结构，是在开发中最常见的使用方式。

2 Mapper 动态代理规范

• 接口名称需要与映射配置文件名称相同
• 映射配置文件中 namespace 必须是接口的全名。
• 接口中的方法名和映射配置文件中的标签的 id 一致。
• 接口中的返回值类型和映射配置文件中的 resultType 的指定的类型一致。

3 Mapper 动态代理的使用

3.1搭建环境

3.1.1 创建项目

3.1.2 添加 jar 包

3.1.3 创建实体

package com.bjsxt.pojo;

import java.io.Serializable;

public class Users implements Serializable{
    private int userid;
    private String username;
    private String usersex;


    public int getUserid() {
        return userid;
    }

    public void setUserid(int userid) {
        this.userid = userid;
    }

    public String getUsername() {
        return username;
    }

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

    public String getUsersex() {
        return usersex;
    }

    public void setUsersex(String usersex) {
        this.usersex = usersex;
    }
    @Override
    public String toString() {
        return "Users{" +
                "userid=" + userid +
                ", username='" + username + '\'' +
                ", usersex='" + usersex + '\'' +
                '}';
    }
}

3.1.4 创建 Mybatis 工具类

package com.bjsxt.utils;

import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;

import java.io.IOException;
import java.io.InputStream;

public class MybatisUtils {
    private static ThreadLocal<SqlSession> threadLocal = new ThreadLocal<>();
    private static SqlSessionFactory sqlSessionFactory = null;
    static{
        //创建SqlSessionFactory
        InputStream is = null;
        try{
            is = Resources.getResourceAsStream("mybatis-cfg.xml");
        }catch (IOException e){
            e.printStackTrace();
        }
        sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
    }

    //获取SqlSession
    public static SqlSession getSqlSession(){
        SqlSession sqlSession = threadLocal.get();
        if(sqlSession == null){
            sqlSession = sqlSessionFactory.openSession();
            threadLocal.set(sqlSession);
        }
        return sqlSession;
    }

    //关闭SqlSession
    public static void closeSqlSession(){
        SqlSession sqlSession = threadLocal.get();
        if(sqlSession != null){
            sqlSession.close();
            threadLocal.set(null);
        }
    }
}

3.2配置 Mybatis 框架

3.2.1 添加 db.properteis 文件

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/bjsxt
jdbc.username=root
jdbc.password=root

3.2.2 添加 log4j.properties 文件

log4j.rootLogger=debug,console,logfile

### appender.console输出到控制台 ###
log4j.appender.console=org.apache.log4j.ConsoleAppender
log4j.appender.console.layout=org.apache.log4j.PatternLayout
log4j.appender.console.layout.ConversionPattern=<%d> %5p (%F:%L) [%t] (%c) - %m%n
log4j.appender.console.Target=System.out

### appender.logfile输出到日志文件 ###
log4j.appender.logfile=org.apache.log4j.RollingFileAppender
log4j.appender.logfile.File=SysLog.log
log4j.appender.logfile.MaxFileSize=500KB
log4j.appender.logfile.MaxBackupIndex=7
log4j.appender.logfile.layout=org.apache.log4j.PatternLayout
log4j.appender.logfile.layout.ConversionPattern=<%d> %p (%F:%L) [%t] %c - %m%n

3.2.3 添加全局配置文件

DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    
    <properties resource="db.properties"/>

    <settings>
        <setting name="useGeneratedKeys" value="true"/>
    settings>

    
    <typeAliases>
        <package name="com.bjsxt.pojo"/>
    typeAliases>

    
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC">transactionManager>
            <dataSource type="POOLED">
                <property name="driver" value="${jdbc.driver}"/>
                <property name="url" value="${jdbc.url}"/>
                <property name="username" value="${jdbc.username}"/>
                <property name="password" value="${jdbc.password}"/>
            dataSource>
        environment>
    environments>

    
    <mappers>
        <package name="com.bjsxt.mapper"/>
    mappers>
configuration>

3.2.4 添加 UsersMapper 接口

package com.bjsxt.mapper;

import com.bjsxt.pojo.Users;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.session.RowBounds;

import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.Set;

public interface UsersMapper {
    
}

3.2.5 添加 UsersMapper 映射配置文件

DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.bjsxt.mapper.UsersMapper">

mapper>

3.3实现查询所有用户

3.3.1 修改映射配置文件

DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.bjsxt.mapper.UsersMapper">
    <cache/>
    
    <select id="selectUsersAll" resultType="users">
         select * from users
    select>

mapper>

3.3.2 修改 UsersMapper 接口添加抽象方法

package com.bjsxt.mapper;

import com.bjsxt.pojo.Users;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.session.RowBounds;

import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.Set;

public interface UsersMapper {
    List<Users> selectUsersAll();
}

3.3.3 创建业务层接口

package com.bjsxt.serivce;

import com.bjsxt.pojo.Users;

import java.util.List;

public interface UsersService {
    List<Users> findUsersAll();
  
}

3.3.4 创建业务层接口实现类

package com.bjsxt.serivce.impl;

import com.bjsxt.mapper.UsersMapper;
import com.bjsxt.pojo.Users;
import com.bjsxt.serivce.UsersService;
import com.bjsxt.utils.MybatisUtils;
import org.apache.ibatis.session.SqlSession;

import java.util.List;

public class UsersServiceImpl implements UsersService {
    @Override
    public List<Users> findUsersAll() {
        List<Users> list = null;
        try{
            SqlSession sqlSession = MybatisUtils.getSqlSession();
           //getMapper方法的作用是根据给定的接口的Class对象，生成该接口的接口实现类的代理对象
            UsersMapper mapper = sqlSession.getMapper(UsersMapper.class);
            list = mapper.selectUsersAll();
        }catch(Exception e){
            e.printStackTrace();
        }finally{
            MybatisUtils.closeSqlSession();
        }
        return list;
    }
}

3.3.5 创建测试类

package com.bjsxt.test;

import com.bjsxt.pojo.Users;
import com.bjsxt.serivce.UsersService;
import com.bjsxt.serivce.impl.UsersServiceImpl;

import java.util.List;

public class SelectUsersAllTest {
    public static void main(String[] args) {
        UsersService usersService = new UsersServiceImpl();
        List<Users> list = usersService.findUsersAll();
        //list.forEach(e -> System.out.println(e));
        list.forEach(System.out::println);
        //以上两种写法等同于
        /*
        for (Users e:list){
            System.out.println(e);
        }
        */
    }
}

3.4实现根据用户 ID 查询用户

3.4.1 修改映射配置文件

DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.bjsxt.mapper.UsersMapper">
    <cache/>
    
    <select id="selectUsersAll" resultType="users">
         select * from users
    select>

    
    <select id="selectUsersById" resultType="users">
         select * from users where userid = #{userid}
    select>
mapper>

3.4.2 修改 UsersMapper 接口添加抽象方法

package com.bjsxt.mapper;

import com.bjsxt.pojo.Users;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.session.RowBounds;

import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.Set;

public interface UsersMapper {
    List<Users> selectUsersAll();
    Users selectUsersById(int userid);
}

3.4.3 修改业务层接口

package com.bjsxt.serivce;

import com.bjsxt.pojo.Users;

import java.util.List;

public interface UsersService {
    List<Users> findUsersAll();
    Users findUsersById(int userid);
}

3.4.4 修改业务层接口实现类

package com.bjsxt.serivce.impl;

import com.bjsxt.mapper.UsersMapper;
import com.bjsxt.pojo.Users;
import com.bjsxt.serivce.UsersService;
import com.bjsxt.utils.MybatisUtils;
import org.apache.ibatis.session.SqlSession;

import java.util.List;

public class UsersServiceImpl implements UsersService {
    @Override
    public List<Users> findUsersAll() {
        List<Users> list = null;
        try{
            SqlSession sqlSession = MybatisUtils.getSqlSession();
           //getMapper方法的作用是根据给定的接口的Class对象，生成该接口的接口实现类的代理对象
            UsersMapper mapper = sqlSession.getMapper(UsersMapper.class);
            list = mapper.selectUsersAll();
        }catch(Exception e){
            e.printStackTrace();
        }finally{
            MybatisUtils.closeSqlSession();
        }
        return list;
    }

    @Override
    public Users findUsersById(int userid) {
        Users users = null;
        try{
            SqlSession sqlSession = MybatisUtils.getSqlSession();
            UsersMapper mapper = sqlSession.getMapper(UsersMapper.class);
            users = mapper.selectUsersById(userid);
        }catch(Exception e){
            e.printStackTrace();
        }finally{
            MybatisUtils.closeSqlSession();
        }
        return users;
    }
}

3.4.5 创建测试类

package com.bjsxt.test;

import com.bjsxt.pojo.Users;
import com.bjsxt.serivce.UsersService;
import com.bjsxt.serivce.impl.UsersServiceImpl;

public class SelectUsersByIdTest {
    public static void main(String[] args) {
        UsersService usersService = new UsersServiceImpl();
        Users users = usersService.findUsersById(1);
        System.out.println(users);
    }
}

4 Mapper 动态代理模式下的多参数处理

4.1顺序传参法

在映射文件中，SQL 语句中的参数需要使用 arg0，arg1…或者 param1，param2…表示参 数的顺序。此方法可读性低，且要求参数的顺序不能出错，在开发中不建议使用。

修改UserMapper接口

package com.bjsxt.mapper;

import com.bjsxt.pojo.Users;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.session.RowBounds;

import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.Set;

public interface UsersMapper {
    List<Users> selectUsersAll();
    Users selectUsersById(int userid);
    List<Users> selectUsersOrderParam(String username,String usersex);

}

修改Mapper配置

DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.bjsxt.mapper.UsersMapper">
    <cache/>
    
    <select id="selectUsersAll" resultType="users">
         select * from users
    select>

    
    <select id="selectUsersById" resultType="users">
         select * from users where userid = #{userid}
    select>

	
    <select id="selectUsersOrderParam" resultType="users">
        select * from users where username = #{arg0} and usersex= #{arg1}
    select>   
    
    <select id="selectUsersOrderParam" resultType="users">
        select * from users where username = #{param1} and usersex= #{param2}
    select>
mapper>

添加测试类

package com.bjsxt.test;

import com.bjsxt.mapper.UsersMapper;
import com.bjsxt.pojo.Users;
import com.bjsxt.utils.MybatisUtils;
import org.apache.ibatis.session.SqlSession;

import java.util.List;

public class SelectUsersOrderParamTest {

    public static void main(String[] args) {
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UsersMapper usersMapper = sqlSession.getMapper(UsersMapper.class);
        List<Users> list = usersMapper.selectUsersOrderParam("bjsxt","male");
        list.forEach(System.out::println);
        MybatisUtils.closeSqlSession();
    }
}

4.2@Param 注解传参法

在接口方法的参数列表中通过@Param 注解来定义参数名称，在 SQL 语句中通过注解中 所定义的参数名称完成参数位置的指定。
此方式在参数不多的情况还是比较直观的，推荐使用。

修改Mapper配置

DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.bjsxt.mapper.UsersMapper">
    <cache/>
    
    <select id="selectUsersAll" resultType="users">
         select * from users
    select>

    
    <select id="selectUsersById" resultType="users">
         select * from users where userid = #{userid}
    select>

    
    <select id="selectUsersOrderParam" resultType="users">
        select * from users where username = #{param1} and usersex= #{param2}
    select>

    
    <select id="selectUsersAnnParam" resultType="users">
        select * from users where username = #{name} and usersex= #{sex}
    select>

mapper>

修改UsersMapper接口

package com.bjsxt.mapper;

import com.bjsxt.pojo.Users;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.session.RowBounds;

import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.Set;

public interface UsersMapper {
    List<Users> selectUsersAll();
    Users selectUsersById(int userid);
    List<Users> selectUsersOrderParam(String username,String usersex);
    List<Users> selectUsersAnnParam(@Param("name") String username,@Param("sex") String usersex);
}

添加测试类

package com.bjsxt.test;

import com.bjsxt.mapper.UsersMapper;
import com.bjsxt.pojo.Users;
import com.bjsxt.utils.MybatisUtils;
import org.apache.ibatis.session.SqlSession;

import java.util.List;

public class SelectUsersAnnParamTest {
    public static void main(String[] args) {
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UsersMapper usersMapper = sqlSession.getMapper(UsersMapper.class);
        List<Users> list = usersMapper.selectUsersAnnParam("bjsxt","male");
        list.forEach(System.out::println);
        MybatisUtils.closeSqlSession();
    }
}

4.3POJO 传参法

在 Mapper 动态代理中也可以使用 POJO 作为传递参数的载体，在 SQL 语句中绑定参数 时使用 POJO 的属性名作为参数名即可。此方式推荐使用。

修改Mapper配置

DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.bjsxt.mapper.UsersMapper">
    <cache/>
    
    <select id="selectUsersAll" resultType="users">
         select * from users
    select>

    
    <select id="selectUsersById" resultType="users">
         select * from users where userid = #{userid}
    select>

    
    <select id="selectUsersOrderParam" resultType="users">
        select * from users where username = #{param1} and usersex= #{param2}
    select>

    
    <select id="selectUsersAnnParam" resultType="users">
        select * from users where username = #{name} and usersex= #{sex}
    select>

    
    <select id="selectUsersPOJOParam" resultType="users">
        select * from users where username = #{username} and usersex= #{usersex}
    select>
mapper>

修改UsersMapper接口

package com.bjsxt.mapper;

import com.bjsxt.pojo.Users;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.session.RowBounds;

import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.Set;

public interface UsersMapper {
    List<Users> selectUsersAll();
    Users selectUsersById(int userid);
    List<Users> selectUsersOrderParam(String username,String usersex);
    List<Users> selectUsersAnnParam(@Param("name") String username,@Param("sex") String usersex);
    List<Users> selectUsersPOJOParam(Users users);
    }

添加测试类

package com.bjsxt.test;

import com.bjsxt.mapper.UsersMapper;
import com.bjsxt.pojo.Users;
import com.bjsxt.utils.MybatisUtils;
import org.apache.ibatis.session.SqlSession;

import java.util.List;

public class SelectUsersPOJOParamTest {
    public static void main(String[] args) {
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UsersMapper usersMapper = sqlSession.getMapper(UsersMapper.class);
        Users users = new Users();
        users.setUsername("bjsxt");
        users.setUsersex("male");
        List<Users> list = usersMapper.selectUsersPOJOParam(users);
        list.forEach(System.out::println);
        MybatisUtils.closeSqlSession();
    }
}

4.4 Map 传参法

在 Mapper 动态代理中也可以使用 Map 作为传递参数的载体，在 SQL 语句中绑定参数 时使用 Map 的 Key 作为参数名即可。此方法适合在传递多参数时，如果没有 POJO 能与参数 匹配，可以使用该方式传递参数。推荐使用。

MyBatis 传递 map 参数时，如果传递参数中没有对应的 key 值，在执行 sql 语句时默认 取的是 null。

修改Mapper配置

DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.bjsxt.mapper.UsersMapper">
    <cache/>
    
    <select id="selectUsersAll" resultType="users">
         select * from users
    select>

    
    <select id="selectUsersById" resultType="users">
         select * from users where userid = #{userid}
    select>

    
    <select id="selectUsersOrderParam" resultType="users">
        select * from users where username = #{param1} and usersex= #{param2}
    select>

    
    <select id="selectUsersAnnParam" resultType="users">
        select * from users where username = #{name} and usersex= #{sex}
    select>

    
    <select id="selectUsersPOJOParam" resultType="users">
        select * from users where username = #{username} and usersex= #{usersex}
    select>

    
    <select id="selectUsersMapParam" resultType="users">
        select * from users where username = #{keyname} and usersex= #{keysex}
    select>
mapper>

修改UsersMapper接口

package com.bjsxt.mapper;

import com.bjsxt.pojo.Users;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.session.RowBounds;

import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.Set;

public interface UsersMapper {
    List<Users> selectUsersAll();
    Users selectUsersById(int userid);
    List<Users> selectUsersOrderParam(String username,String usersex);
    List<Users> selectUsersAnnParam(@Param("name") String username,@Param("sex") String usersex);
    List<Users> selectUsersPOJOParam(Users users);
    List<Users> selectUsersMapParam(Map<String,String> map);
    }

添加测试类

package com.bjsxt.test;

import com.bjsxt.mapper.UsersMapper;
import com.bjsxt.pojo.Users;
import com.bjsxt.utils.MybatisUtils;
import org.apache.ibatis.session.SqlSession;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class SelectUsersMapParamTest {
    public static void main(String[] args) {
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UsersMapper usersMapper = sqlSession.getMapper(UsersMapper.class);
        Map<String,String> map = new HashMap<>();
        map.put("keyname","bjsxt");
        map.put("keysex","male");
        List<Users> list = usersMapper.selectUsersMapParam(map);
        list.forEach(System.out::println);
        MybatisUtils.closeSqlSession();
    }
}

5 映射配置文件中的特殊字符处理

在 Mybatis 的映射配置文件中不可以使用一些特殊字符，如：<，>。

5.1使用符号实体

我们可以使用符号的实体来表示：

DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.bjsxt.mapper.UsersMapper">
    <cache/>
    
    <select id="selectUsersAll" resultType="users">
         select * from users
    select>

    
    <select id="selectUsersById" resultType="users">
         select * from users where userid = #{userid}
    select>

    
    <select id="selectUsersOrderParam" resultType="users">
        select * from users where username = #{param1} and usersex= #{param2}
    select>

    
    <select id="selectUsersAnnParam" resultType="users">
        select * from users where username = #{name} and usersex= #{sex}
    select>

    
    <select id="selectUsersPOJOParam" resultType="users">
        select * from users where username = #{username} and usersex= #{usersex}
    select>

    
    <select id="selectUsersMapParam" resultType="users">
        select * from users where username = #{keyname} and usersex= #{keysex}
    select>

    
    <select id="selectUsers" resultType="users">
        select * from users where userid ≥ #{userid}
    select>
 mapper>

修改UsersMapper接口

package com.bjsxt.mapper;

import com.bjsxt.pojo.Users;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.session.RowBounds;

import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.Set;

public interface UsersMapper {
    List<Users> selectUsersAll();
    Users selectUsersById(int userid);
    List<Users> selectUsersOrderParam(String username,String usersex);
    List<Users> selectUsersAnnParam(@Param("name") String username,@Param("sex") String usersex);
    List<Users> selectUsersPOJOParam(Users users);
    List<Users> selectUsersMapParam(Map<String,String> map);
    List<Users> selectUsers(int userid);
    }

添加测试类

package com.bjsxt.test;

import com.bjsxt.mapper.UsersMapper;
import com.bjsxt.pojo.Users;
import com.bjsxt.utils.MybatisUtils;
import org.apache.ibatis.session.SqlSession;

import java.util.List;

public class SelectUsersTest {
    public static void main(String[] args) {
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UsersMapper usersMapper = sqlSession.getMapper(UsersMapper.class);
        List<Users> list = usersMapper.selectUsers(1);
        list.forEach(System.out::println);
        MybatisUtils.closeSqlSession();
    }
}

5.2使用 CDATA 区

CDATA：全称为 Character Data,以""，CDATA 中的内容不会被解析程 序解析。

 
    <select id="selectUsers" resultType="users">
        select * from users where userid  ]]> #{userid}
    select>

6 Mybatis 的分页查询

6.1使用 RowBounds

RowBounds 是 Mybatis 提供的一个专门处理分页的对象。在 RowBounds 对象中有两个 成员变量：
offset：偏移量，从 0 开始计数
limit：限制条数
使用 RowBounds 进行分页，非常方便，不需要在 SQL 语句中写 limit，即可完成分页 功能。但是由于它是在 SQL 查询出所有结果的基础上截取数据的，所以在数据量大的 SQL 中并不适用，它更适合在返回数据结果较少的查询中使用。

6.1.1 修改映射配置文件

 
    <select id="selectUsersRowBounds" resultType="users">
        select * from users
    select>

6.1.2 修改 UsersMapper 接口

List<Users> selectUsersRowBounds(RowBounds rowBounds);

6.1.3 创建测试类

package com.bjsxt.test;

import com.bjsxt.mapper.UsersMapper;
import com.bjsxt.pojo.Users;
import com.bjsxt.utils.MybatisUtils;
import org.apache.ibatis.session.RowBounds;
import org.apache.ibatis.session.SqlSession;

import java.util.List;

public class SelectUsersRowBoundsTest {
    public static void main(String[] args) {
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UsersMapper usersMapper = sqlSession.getMapper(UsersMapper.class);
        RowBounds rowBounds = new RowBounds(1,1);
        List<Users> list = usersMapper.selectUsersRowBounds(rowBounds);
        list.forEach(System.out::println);
        MybatisUtils.closeSqlSession();
    }
}

6.2使用 SQL 语句分页

在分页查询时，如果返回的结果较多，那么需要使用特定的 SQL 语句来实现分页处理。 在 MySQL 数据库中我们可以使用 limit 实现分页。

6.2.1 修改映射配置文件

    <select id="selectUsersLimit" resultType="users">
        select * from users limit #{offset},#{limit}
    select>

6.2.2 修改 UsersMapper

List<Users> selectUsersLimit(@Param("offset") int offset,@Param("limit") int limit);

6.2.3 创建测试类

package com.bjsxt.test;

import com.bjsxt.mapper.UsersMapper;
import com.bjsxt.pojo.Users;
import com.bjsxt.utils.MybatisUtils;
import org.apache.ibatis.session.RowBounds;
import org.apache.ibatis.session.SqlSession;

import java.util.List;

public class SelectUsersLimitTest {
    public static void main(String[] args) {
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UsersMapper usersMapper = sqlSession.getMapper(UsersMapper.class);
        List<Users> list = usersMapper.selectUsersLimit(0,1);
        list.forEach(System.out::println);
        MybatisUtils.closeSqlSession();
    }
}

7 Mapper 动态代理模式下的 DML 操作

7.1实现添加用户业务

7.1.1 修改映射配置文件

  
    <insert id="insertUsers" >
        insert into users values(default ,#{username},#{usersex})
    insert>

7.1.2 修改 UsersMapper 接口

 int insertUsers(Users users);

7.1.3 创建测试类

package com.bjsxt.test;

import com.bjsxt.mapper.UsersMapper;
import com.bjsxt.pojo.Users;
import com.bjsxt.utils.MybatisUtils;
import org.apache.ibatis.session.SqlSession;

public class InsertUsersTest {
    public static void main(String[] args) {
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UsersMapper usersMapper = sqlSession.getMapper(UsersMapper.class);
        Users users = new Users();
        users.setUsername("itbz");
        users.setUsersex("male");
        int flag = usersMapper.insertUsers(users);
        sqlSession.commit();
        System.out.println(flag);
        MybatisUtils.closeSqlSession();
    }
}

8 主键值回填

在数据库中插入数据时，有时我们是需要获取新数据的主键值。在 Mybatis 中支持主键 值回填，可以让我们更够更方便的获取新添加数据的主键值。

Mybatis 中支持两种方法获取主键：
获取自增主键的值。如：MySQL、SqlServer
获取非自增主键的值。如 Oracle

8.1获取自增主键值

8.1.1 开启自动获取自增主键值

8.1.1.1 局部配置 映射配置文件

 
    <insert id="insertUsersGetKey" useGeneratedKeys="true" keyProperty="userid">
        insert into users values(default ,#{username},#{usersex})
    insert>

修改UsersMapper接口

void insertUsersGetKey(Users users);

添加测试类

package com.bjsxt.test;

import com.bjsxt.mapper.UsersMapper;
import com.bjsxt.pojo.Users;
import com.bjsxt.utils.MybatisUtils;
import org.apache.ibatis.session.SqlSession;

public class InsertUsersGetKeyTest {
    public static void main(String[] args) {
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UsersMapper usersMapper = sqlSession.getMapper(UsersMapper.class);
        Users users = new Users();
        users.setUsername("itbz-sxt3");
        users.setUsersex("male");
        usersMapper.insertUsersGetKey(users);
        sqlSession.commit();
        System.out.println(users.getUserid());
        MybatisUtils.closeSqlSession();
    }
}

以上方式是只在局部配置有效，想要全局都可以使用需要配置全局配置文件

8.1.1.2 全局配置

全局配置文件

<settings>
        <setting name="useGeneratedKeys" value="true"/>
    settings>

映射配置文件

 
    <insert id="insertUsersGetKey" keyProperty="userid">
        insert into users values(default ,#{username},#{usersex})
    insert>

8.1.2 修改 UsersMapper 接口

void insertUsersGetKey(Users users);

8.1.3 创建测试类

package com.bjsxt.test;

import com.bjsxt.mapper.UsersMapper;
import com.bjsxt.pojo.Users;
import com.bjsxt.utils.MybatisUtils;
import org.apache.ibatis.session.SqlSession;

public class InsertUsersGetKeyTest {
    public static void main(String[] args) {
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UsersMapper usersMapper = sqlSession.getMapper(UsersMapper.class);
        Users users = new Users();
        users.setUsername("itbz-sxt3");
        users.setUsersex("male");
        usersMapper.insertUsersGetKey(users);
        sqlSession.commit();
        System.out.println(users.getUserid());
        MybatisUtils.closeSqlSession();
    }
}

8.2获取非自增主键值

8.2.1 修改映射配置文件

  
    <insert id="insertUsersGetKey2">
        <selectKey order="AFTER" keyProperty="userid" resultType="int">
           
            SELECT LAST_INSERT_ID()
        selectKey>
        insert into users values(default ,#{username},#{usersex})
    insert>

8.2.2 修改 UsersMapper 接口

void insertUsersGetKey2(Users users);

8.2.3 创建测试类

package com.bjsxt.test;

import com.bjsxt.mapper.UsersMapper;
import com.bjsxt.pojo.Users;
import com.bjsxt.utils.MybatisUtils;
import org.apache.ibatis.session.SqlSession;

public class InsertUserGetKey2Test {
    public static void main(String[] args) {
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UsersMapper usersMapper = sqlSession.getMapper(UsersMapper.class);
        Users users = new Users();
        users.setUsername("itbz-sxt4");
        users.setUsersex("male");
        usersMapper.insertUsersGetKey2(users);
        sqlSession.commit();
        System.out.println(users.getUserid());
        MybatisUtils.closeSqlSession();
    }
}

9 Mapper 动态代理原理

9.1获取代理对象 MapperProxy

@Override 
public <T> T getMapper(Class<T> type) { 
	return configuration.getMapper(type, this); 
}

public <T> T getMapper(Class<T> type, SqlSession sqlSession) { 
	return mapperRegistry.getMapper(type, sqlSession); 
}

public <T> T getMapper(Class<T> type, SqlSession sqlSession) {
	final MapperProxyFactory<T> mapperProxyFactory = (MapperProxyFactory<T>) knownMappers.get(type);
	if (mapperProxyFactory == null) {
		throw new BindingException("Type " + type + " is not known to theMapperRegistry.");
	}
	try { 
		return mapperProxyFactory.newInstance(sqlSession); 
	} catch (Exception e) { 
		throw new BindingException("Error getting mapper instance. Cause: " + e, e); 
	} 
}

public T newInstance(SqlSession sqlSession) { 
	final MapperProxy<T> mapperProxy = new MapperProxy<>(sqlSession, mapperInterface, methodCache); 
	return newInstance(mapperProxy);
}

9.2通过 MapperMethod 对象执行对应的操作

public Object invoke(Object proxy, Method method, Object[] args, SqlSession sqlSession) throws Throwable { 
	return mapperMethod.execute(sqlSession, args); 
}

public Object execute(SqlSession sqlSession, Object[] args) { 
	Object result; 
	switch (command.getType()) { 
		case INSERT: { 
			Object param = method.convertArgsToSqlCommandParam(args); 
			result = rowCountResult(sqlSession.insert(command.getName(), param)); 
			break; 
		}
		case UPDATE: { 
			Object param = method.convertArgsToSqlCommandParam(args); 
			result = rowCountResult(sqlSession.update(command.getName(), param)); 
			break; 
		}
		case DELETE: { 
			Object param = method.convertArgsToSqlCommandParam(args); 
			result = rowCountResult(sqlSession.delete(command.getName(), param));
			break; 
		}
		case SELECT: 
			if (method.returnsVoid() && method.hasResultHandler()) { 
				executeWithResultHandler(sqlSession, args); 
				result = null; 
			} else if (method.returnsMany()) { 
				result = executeForMany(sqlSession, args); 
			} else if (method.returnsMap()) { 
				result = executeForMap(sqlSession, args); 
			} else if (method.returnsCursor()) { 
				result = executeForCursor(sqlSession, args); 
			} else { 
				Object param = method.convertArgsToSqlCommandParam(args); 
				result = sqlSession.selectOne(command.getName(), param); 
				if (method.returnsOptional() && (result == null || !method.getReturnType().equals(result.getClass()))) { 
					result = Optional.ofNullable(result); 
				} 
			}	
			break; 
		case FLUSH: 
		result = sqlSession.flushStatements(); 
		break; 
	default: 
		throw new BindingException("Unknown execution method for: " + command.getName()); 
		}
		if (result == null && method.getReturnType().isPrimitive() && !method.returnsVoid()) { 
			throw new BindingException("Mapper method '" + command.getName() + " attempted to return null from a method with a primitive return type (" + method.getReturnType() + ")."); 
		}
		return result; 
}	

MyBatis实战【下】

你可能感兴趣的:(MyBatis,java,后端,mybatis)

• JavaScript面试：什么是纯函数？ 魂斗驴
  纯函数对于多种用途至关重要，包括函数式编程，可靠的并发和React+Redux应用程序。但是“纯函数”是什么意思？在我们研究纯函数是什么之前，仔细研究一下函数可能是一个好主意。观察它们的方式可能有所不同，这将使函数式编程更易于理解。什么是函数？函数是一种方法，它需要一些输入，称为自变量，并产生一些输出称为返回值。函数可以达到以下目的：映射：根据给定的输入产生一些输出。函数将输入值映射到输出值。过程
• 【安卓面试】 木啊木啊木 android面试职场和发展
  百度-APP相关安卓开发数组排序view流程和surfaceViewrecycleViewview绘制流程停止一个线程停止线程的场景输入一个url观察者模式观察者模式的基本流程：安卓内存共享JNISQLkotlin与java混用的问题Linux命令及原理app启动流程小程序原理加密算法对称加密非对称加密安卓持久化存储方式启动模式和场景ANR以及如何避免数组排序八大排序-及复杂度viewView是用
• java实现es分页查询_elasticsearch high level rest api分页查询数据 weixin_42565971 java实现es分页查询
  Transport方式查询数据，在今后的elasticsearch中将不在维护，官方推荐用用highlevelrestapi或者lowerlevelapi去操作elasticsearch中的数据。在elasticsearch的增删改查操作中，其实最复杂的也就是分页查询了，根据elasticsearch官方资料，做个简单的笔记.1.准备jar包,我用的elasticsearch7.3版本,各版本需要
• 一分钟看懂：前端和后端，哪个更简单？转行程序员必看！ Python自动化办公社区 前端程序员
  大家好，这里是程序员晚枫，专注于转行程序员的1对1咨询，小红薯也叫这个名。想转行程序员的朋友，在选择方向的时候都会遇到一个问题：哪个技术方向适合我？前端和后端哪个更简单？今天咱们就来一起分析一下~1、一样难很多网上的消息或者培训机构的广告会告诉你：前端比后端简单。这种回复，更多是一种营销套路。为什么？单从技术本身来说，前端的简单，仅仅体现在刚入门的时候，因为前端代码效果你能看到。学到后面你会发现，
• ECMAScript与JavaScript的区别 vvvae1234 ecmascript
  在现代Web开发中，JavaScript是一种不可或缺的语言，而ECMAScript则是JavaScript的标准化版本。理解二者之间的差异，有助于前端开发者更好地编写高效、可维护的代码。本指南将深入探讨ECMAScript与JavaScript的区别，并通过实际案例演示如何在实际开发中应用这些知识。2.ECMAScript和JavaScript简介2.1什么是JavaScript？JavaScr
• 如何用JavaScript实现视频观看时间追踪 瑆箫 javascript音视频开发语言
  博客：如何用JavaScript实现视频观看时间追踪|瑆箫博客在网页开发中，跟踪用户与多媒体内容（如视频）的互动是一项常见需求。无论是教育平台、数据分析，还是用户参与度统计，监控用户如何观看视频内容都能提供宝贵的见解。这篇文章将探索如何使用JavaScript实现视频播放时长的跟踪。目标我们的目标是跟踪用户观看视频的总时长，包括暂停的时间，并将这些信息更新到后台系统。我们将通过捕获播放、暂停和结束
• Java入门------static关键字和静态属性、方法 从未止步.. JavaSE基础javajvm开发语言
  static关键字：在定义一个类时，只是描述某事物的特征和行为，并没有产生具体的数据，只有通过new关键字创建该类的实例对象时，才会开辟栈内存及内存，在堆内存中要保存对象的属性时，每个对象会有自己的属性。如果希望某些属性被所有对象共享，就必须将其声明为static属性，如果属性使用了static关键字进行修饰，则该属性可以直接使用类名称进行调用，static关键字还可以修饰成员方法。静态属性：如果
• ConcurrentHashMap实现原理 CodeMaster_37714848 线程安全的hashMap
  ConcurrentHashMap是Java中的一个并发集合类，它用于在多线程环境下高效地存储和操作键值对。它的实现原理旨在提供高效的并发访问，确保线程安全，同时保持较高的性能。下面是ConcurrentHashMap的一些核心实现原理：1.分段锁（SegmentLocking）ConcurrentHashMap的早期实现使用了分段锁（SegmentLocking）。这个策略将整个哈希表划分为多个
• (附论文)基于ssm的高校大学生党建系统(688) KK ??? 媒体学习开发语言springjava
  获取源码请滑到最底部访问官网项目配套调试视频和相对应的软件安装包1、项目描述具体请看视频演示2、项目开发工具开发工具：Idea或Eclipse数据库：MysqlJar包仓库：Maven前端框架：Vue2后端框架：SSM3、项目图片4、演示视频(附论文)基于ssm的高校大学生党建系统(688)
• 2024最新Android大厂面试真题大全（附答案） imtokenmax合约众筹 2024年程序员面试android面试职场和发展
  五、架构设计和设计模式1.谈谈你对Android设计模式的理解2.MVCMVPMVVM原理和区别3.你所知道的设计模式有哪些？4.项目中常用的设计模式5.手写生产者/消费者模式6.写出观察者模式的代码7.适配器模式，装饰者模式，外观模式的异同？8.用到的一些开源框架，介绍一个看过源码的，内部实现过程。9.谈谈对RxJava的理解10.Rxjava发送事件步骤11.RxJava的作用，与平时使用的异
• Java入门：08.Java中的static关键字02（拓展：单例模式） CJH~ java单例模式开发语言
  1.3对象代码段和静态代码段什么是代码段？就是个{}里面包含一堆代码代码段可以写在方法中，也可以写在方法外代码段可以方法中和方法外独立存在，也可以配合着分支结构和循环结构存在classA{ {   ..... }  publicvoidt1(){   {     .....   } }    publicvoidt2(){    if(){      System.out.println()   
• Java入门：05.Java中的数组001 CJH~ 开发语言java
  在本期文章当中，我们将一起了解Java中的数组，那么首先——什么是数组呢？一、什么是数组数组和变量一样也是一个容器，那么它和变量的区别是什么呢？通常来讲，一个变量只能存储一个数据，但数组却可以用来存储一组位置连续的、类型相同的数据(变量)。二、数组类型变量的定义即便如此，但数组本身也是一个数据，它也可以存储在变量或是数组（即多为数组）中。要想把数组存进变量，我们就必须把这个变量定义成数组类型的变量
• Java static关键字（静态变量和静态方法） Itmastergo javajvm开发语言
  在类中，使用static修饰符修饰的属性（成员变量）称为静态变量，也可以称为类变量，常量称为静态常量，方法称为静态方法或类方法，它们统称为静态成员，归整个类所有。静态成员不依赖于类的特定实例，被类的所有实例共享，就是说static修饰的方法或者变量不需要依赖于对象来进行访问，只要这个类被加载，Java虚拟机就可以根据类名找到它们。调用静态成员的语法形式如下：类名.静态成员注意：static修饰的成
• 2024Android面试题合集整理（字节跳动+猿辅导，Android面试相关文章及Github学习资料 2401_83739472 2024年程序员学习android面试职场和发展
  斗鱼1.说说HashMap的原理2.说说Java的内存分区3.讲讲你对垃圾回收机制的了解，老年代有什么算法？4.说说你对volatile字段有什么用途？5.说说事件分发机制，怎么写一个不能滑动的ViewPager6.说说你对类加载机制的了解？DexClassLoader与PathClassLoader的区别7.说说插件化的原理，资源的插件化id重复如何解决？8.mvp与mvvm模式的区别是什么？9
• 2025毕业设计指南：如何用Hadoop构建超市进货推荐系统？大数据分析助力精准采购 计算机编程指导师 Java实战集Python实战集大数据实战集课程设计hadoop数据分析springbootjava进货python
  ✍✍计算机编程指导师⭐⭐个人介绍：自己非常喜欢研究技术问题！专业做Java、Python、小程序、安卓、大数据、爬虫、Golang、大屏等实战项目。⛽⛽实战项目：有源码或者技术上的问题欢迎在评论区一起讨论交流！⚡⚡Java实战|SpringBoot/SSMPython实战项目|Django微信小程序/安卓实战项目大数据实战项目⚡⚡文末获取源码文章目录⚡⚡文末获取源码基于hadoop的超市进货推荐系
• React 服务器组件 exploration-earth 学习
  React服务器组件（RSC）标志着我们在组件渲染策略上的一次深刻范式变迁。与传统上完全依赖客户端运行的React组件截然不同，RSC允许内容在服务器端预先渲染，并仅将必要的数据以最精简的形式发送到客户端。这一创新方法融合了服务器端渲染的效能与客户端交互的灵活性，为用户体验带来了前所未有的提升。React服务器组件的核心优势主要体现在以下几个方面：性能飞跃：RSC通过大幅削减客户端接收的JavaS
• Python基础 木啊木啊木 pythonjvm开发语言
  Python_name_javastring和字符串区别深浅拷贝内存池垃圾回收机制引用增减垃圾回收引用计数标记清除分代回收缓存机制池机制free_list装饰器迭代器提高运行效率的方法函数传递方式name当一个Python文件作为主程序运行时，name__属性的值将被设置为__main。这提供了一种方式，通过判断__name__来执行特定的代码块。如果一个Python文件被其他文件导入，name_
• 【Python系列】异步任务的终止 Kwan的解忧杂货铺@新空间代码工作室 s2Pythonpython开发语言
  欢迎来到我的博客，很高兴能够在这里和您见面！希望您在这里可以感受到一份轻松愉快的氛围，不仅可以获得有趣的内容和知识，也可以畅所欲言、分享您的想法和见解。推荐:kwan的首页,持续学习,不断总结,共同进步,活到老学到老导航檀越剑指大厂系列:全面总结java核心技术,jvm,并发编程redis,kafka,Spring,微服务等常用开发工具系列:常用的开发工具,IDEA,Mac,Alfred,Git,
• 前端图片转Base64编码 _耀北 前端
  在前端将图片转为Base64编码，通常会通过使用JavaScript的FileReader对象。效果图代码步骤说明：1.用户通过文件输入框选择图片。2.FileReader对象读取图片，并将其转为Base64编码。3.读取完成后，图片通过img标签预览，Base64编码会显示在页面上。4.复制按钮：在页面中添加了一个按钮，当图片被加载并生成Base64编码后，按钮会显示出来。5.Clipboard
• 美团4.8后端开发笔试 努力搬砖的小王 算法
  代码仅供参考，不保证全对。排座位#includeusingnamespacestd;intmain(){intn,m,a;cin>>n>>m>>a;for(inti=0;i>arr[i][j];}}for(inti=0;iusingnamespacestd;constintN=1e5+5;intn,x,y;vectoredges[N];intlen,vis[N];voiddfs(intu,intd
• java reactor框架_关于java:Java反应式框架Reactor中的Mono和Flux 中一贝爷 javareactor框架
  1.前言最近写对于响应式编程的货色有点多，很多同学反映对Flux和Mono这两个Reactor中的概念有点懵逼。然而目前Java响应式编程中咱们对这两个对象的接触又最多，诸如SpringWebFlux、RSocket、R2DBC。我开始也对这两个对象头疼，所以明天咱们就简略来探讨一下它们。2.响应流的特点要搞清楚这两个概念，必须说一下响应流标准。它是响应式编程的基石。他具备以下特点：响应流必须是无
• java reactor模式例子_Netty Reactor模式实现原理详解 weixin_39923623 javareactor模式例子
  在前面的文章中(Reactor模型详解)，我们讲解了Reactor模式的各种演变形式，本文主要讲解的则是Netty是如何实现Reactor模式的。这里关于Netty实现的Reactor模式，需要说明的是，其实现的模式如下图所示：对于Netty使用的Reactor模式，其主要特点如下：使用一个线程作为mainReactor，专门用于监听客户端的连接事件，当获取到事件之后就将该事件交由Acceptor
• MyBatis之手动映射 cyt涛 javamybatis手动映射resultMap数据库xmlXML查询
  在一些简单的场景下，MyBatis能够自动完成对象和数据库字段之间的映射，这时就不需要手动映射。手动映射通常在以下情况下需要使用：复杂查询或结果：当查询返回的结果结构与实体类不完全匹配，或者返回的结果需要进行复杂的处理时。多表关联查询：当通过SQL进行多表联合查询时，返回的结果可能包含多个实体类的字段，这时需要手动映射结果到特定的对象。非标准字段名：数据库的字段名与实体类属性名不一致，自动映射工具
• Nginx的5种负载均衡配置 一只不想敲代码的程序猿 负载均衡服务器nginxjava运维
  Nginx在web应用的部署中，作为一种轻量级的负载均衡服务器，起到很强大的作用，其中的常见5种负载均衡的模式也是我们最常用的，下面给大家介绍一下相关的配置。Nginx负载的5种策略设置方法：轮询（默认）指定权重IP绑定ip_hashfairurl_hash1、轮询（默认）每个请求按时间顺序逐一分配到不同的后端服务器，如果后端服务器down掉，能自动剔除。轮询：nginx默认就是轮询其权重都默认为
• Java集合 golove666 后端java集合框架Java集合线程安全
  Java集合一、什么是Java集合？主要组成部分：二、Collections工具类1.**排序相关方法**：2.**查找和替换相关方法**：3.**同步和不可变集合相关方法**：4.**打乱顺序相关方法**：5.**集合频率与填充相关方法**：6.**集合比较相关方法**：7.**集合旋转相关方法**：8.**集合交换相关方法**：9.**集合填充相关方法**：10.**空集合相关方法**：三、集
• 微信小程序中数值计算的精度丢失问题 WorkAndDebugger 微信小程序微信小程序
  在微信小程序中，当你遇到数值计算的精度丢失问题时，主要是因为JavaScript在处理浮点数时存在固有的精度问题。这是因为计算机内部使用二进制形式存储数字，而某些十进制小数在二进制中无法精确表示，从而导致了精度误差。解决这个问题的方法有几个：使用整数运算：如果你的应用允许，可以将所有涉及的小数转换为整数再进行计算。例如，将货币值乘以100转换为分进行计算，最后再除以100转换回元。function
• java 接口创建对象 专注API从业者 经验分享电商平台API接口java开发语言大数据数据库数据挖掘
  Java接口创建对象：深度解析与示例在Java编程中，接口是一种非常重要的概念。它不仅为不同类之间的交互提供了规范，也促进了代码的重用和解耦。本文将深入探讨如何在Java中使用接口创建对象，带您理解这一关键特性。什么是接口？接口（Interface）是一种特殊的抽象类，定义了一组方法的声明，但不提供具体的实现。接口允许我们定义类的方法，而不需要指定它们是什么。这使得接口在Java中成为实现多态性、
• nginx配置负载均衡的几种方式 itbigold nginx负载均衡
  1，轮询（默认）每个请求按时间顺序逐一分配到不同的后端服务器，如果后端服务器down掉，能自动剔除。   #反向代理配置   upstreamserver_list{    #这个是tomcat的访问路径    serverlocalhost:8080;    serverlocalhost:9999;   }   server{       listen   80;       server_n
• Ai+若依（集成easyexcel实现excel表格增强） 潇洒（sa）一点 java
  EasyExcel介绍官方地址：EasyExcel官方文档-基于Java的Excel处理工具|EasyExcel官网Java解析、生成Excel比较有名的框架有Apachepoi、jxl。但他们都存在一个严重的问题就是非常的耗内存，poi有一套SAX模式的API可以一定程度的解决一些内存溢出的问题，但POI还是有一些缺陷，比如07版Excel解压缩以及解压后存储都是在内存中完成的，内存消耗依然很大
• 【drools】文档2：起步 drools和dmn 等风来不如迎风去 网络服务入门与实战springdrools
  GettingStartedDroolsUserGuide8.44.0.FinalGettingStartedFirstRuleProjectThisguidewalksyouthroughtheprocessofcreatingasimpleDroolsapplicationproject.PrerequisitesJDK11+withJAVA_HOMEconfiguredappropriate
• Spring4.1新特性——Spring MVC增强 jinnianshilongnian spring 4.1
  目录 Spring4.1新特性——综述 Spring4.1新特性——Spring核心部分及其他 Spring4.1新特性——Spring缓存框架增强 Spring4.1新特性——异步调用和事件机制的异常处理 Spring4.1新特性——数据库集成测试脚本初始化 Spring4.1新特性——Spring MVC增强 Spring4.1新特性——页面自动化测试框架Spring MVC T
• mysql 性能查询优化 annan211 javasql优化mysql应用服务器
  1 时间到底花在哪了？ mysql在执行查询的时候需要执行一系列的子任务，这些子任务包含了整个查询周期最重要的阶段，这其中包含了大量为了 检索数据列到存储引擎的调用以及调用后的数据处理，包括排序、分组等。在完成这些任务的时候，查询需要在不同的地方 花费时间，包括网络、cpu计算、生成统计信息和执行计划、锁等待等。尤其是向底层存储引擎检索数据的调用操作。这些调用需要在内存操
• windows系统配置 cherishLC windows
  删除Hiberfil.sys ：使用命令powercfg -h off 关闭休眠功能即可： http://jingyan.baidu.com/article/f3ad7d0fc0992e09c2345b51.html 类似的还有pagefile.sys msconfig 配置启动项 shutdown 定时关机 ipconfig 查看网络配置 ipconfig /flushdns
• 人体的排毒时间 Array_06 工作
  ======================== ||  人体的排毒时间是什么时候？|| ======================== 转载于： http://zhidao.baidu.com/link?url=ibaGlicVslAQhVdWWVevU4TMjhiKaNBWCpZ1NS6igCQ78EkNJZFsEjCjl3T5EdXU9SaPg04bh8MbY1bR
• ZooKeeper cugfy zookeeper
  Zookeeper是一个高性能，分布式的，开源分布式应用协调服务。它提供了简单原始的功能，分布式应用可以基于它实现更高级的服务，比如同步， 配置管理，集群管理，名空间。它被设计为易于编程，使用文件系统目录树作为数据模型。服务端跑在java上，提供java和C的客户端API。 Zookeeper是Google的Chubby一个开源的实现，是高有效和可靠的协同工作系统，Zookeeper能够用来lea
• 网络爬虫的乱码处理 随意而生 爬虫网络
  下边简单总结下关于网络爬虫的乱码处理。注意，这里不仅是中文乱码，还包括一些如日文、韩文 、俄文、藏文之类的乱码处理，因为他们的解决方式 是一致的，故在此统一说明。     网络爬虫，有两种选择，一是选择nutch、hetriex，二是自写爬虫，两者在处理乱码时，原理是一致的，但前者处理乱码时，要看懂源码后进行修改才可以，所以要废劲一些；而后者更自由方便，可以在编码处理
• Xcode常用快捷键 张亚雄 xcode
  一、总结的常用命令：     隐藏xcode command+h     退出xcode command+q     关闭窗口 command+w     关闭所有窗口 command+option+w     关闭当前
• mongoDB索引操作 adminjun mongodb索引
  一、索引基础：    MongoDB的索引几乎与传统的关系型数据库一模一样，这其中也包括一些基本的优化技巧。下面是创建索引的命令：    > db.test.ensureIndex({"username":1})    可以通过下面的名称查看索引是否已经成功建立： &nbs
• 成都软件园实习那些话 aijuans 成都 软件园 实习
  无聊之中，翻了一下日志，发现上一篇经历是很久以前的事了，悔过~~ 　　断断续续离开了学校快一年了，习惯了那里一天天的幼稚、成长的环境，到这里有点与世隔绝的感觉。不过还好，那是刚到这里时的想法，现在感觉在这挺好，不管怎么样，最要感谢的还是老师能给这么好的一次催化成长的机会，在这里确实看到了好多好多能想到或想不到的东西。 　　都说在外面和学校相比最明显的差距就是与人相处比较困难，因为在外面每个人都
• Linux下FTP服务器安装及配置 ayaoxinchao linuxFTP服务器vsftp
  检测是否安装了FTP [root@localhost ~]# rpm -q vsftpd 如果未安装：package vsftpd is not installed  安装了则显示：vsftpd-2.0.5-28.el5累死的版本信息   安装FTP 运行yum install vsftpd命令，如[root@localhost ~]# yum install vsf
• 使用mongo-java-driver获取文档id和查找文档 BigBird2012 driver
  注：本文所有代码都使用的mongo-java-driver实现。   在MongoDB中，一个集合（collection）在概念上就类似我们SQL数据库中的表（Table），这个集合包含了一系列文档（document）。一个DBObject对象表示我们想添加到集合（collection）中的一个文档（document），MongoDB会自动为我们创建的每个文档添加一个id，这个id在
• JSONObject以及json串 bijian1013 jsonJSONObject
  一.JAR包简介     要使程序可以运行必须引入JSON-lib包，JSON-lib包同时依赖于以下的JAR包：     1.commons-lang-2.0.jar     2.commons-beanutils-1.7.0.jar     3.commons-collections-3.1.jar &n
• [Zookeeper学习笔记之三]Zookeeper实例创建和会话建立的异步特性 bit1129 zookeeper
  为了说明问题，看个简单的代码，   import org.apache.zookeeper.*; import java.io.IOException; import java.util.concurrent.CountDownLatch; import java.util.concurrent.ThreadLocal
• 【Scala十二】Scala核心六：Trait bit1129 scala
  Traits are a fundamental unit of code reuse in Scala. A trait encapsulates method and field definitions, which can then be reused by mixing them into classes. Unlike class inheritance, in which each c
• weblogic version 10.3破解 ronin47 weblogic
  版本：WebLogic Server 10.3 说明：%DOMAIN_HOME%：指WebLogic Server 域(Domain）目录 例如我的做测试的域的根目录 DOMAIN_HOME=D:/Weblogic/Middleware/user_projects/domains/base_domain 1.为了保证操作安全，备份%DOMAIN_HOME%/security/Defa
• 求第n个斐波那契数 BrokenDreams
          今天看到群友发的一个问题：写一个小程序打印第n个斐波那契数。         自己试了下，搞了好久。。。基础要加强了。           &nbs
• 读《研磨设计模式》-代码笔记-访问者模式-Visitor bylijinnan java设计模式
  声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/ import java.util.ArrayList; import java.util.List; interface IVisitor { //第二次分派，Visitor调用Element void visitConcret
• MatConvNet的excise 3改为网络配置文件形式 cherishLC matlab
  MatConvNet为vlFeat作者写的matlab下的卷积神经网络工具包，可以使用GPU。 主页： http://www.vlfeat.org/matconvnet/ 教程： http://www.robots.ox.ac.uk/~vgg/practicals/cnn/index.html 注意：需要下载新版的MatConvNet替换掉教程中工具包中的matconvnet： http
• ZK Timeout再讨论 chenchao051 zookeepertimeouthbase
  http://crazyjvm.iteye.com/blog/1693757 文中提到相关超时问题，但是又出现了一个问题，我把min和max都设置成了180000，但是仍然出现了以下的异常信息： Client session timed out, have not heard from server in 154339ms for sessionid 0x13a3f7732340003
• CASE WHEN 用法介绍 daizj sqlgroup bycase when
  CASE WHEN 用法介绍 1. CASE WHEN 表达式有两种形式 --简单Case函数  CASE sex  WHEN '1' THEN '男'  WHEN '2' THEN '女'  ELSE '其他' END  --Case搜索函数  CASE WHEN sex = '1' THEN
• PHP技巧汇总:提高PHP性能的53个技巧 dcj3sjt126com PHP
  PHP技巧汇总:提高PHP性能的53个技巧　　用单引号代替双引号来包含字符串，这样做会更快一些。因为PHP会在双引号包围的字符串中搜寻变量，　　单引号则不会，注意：只有echo能这么做，它是一种可以把多个字符串当作参数的函数译注：　　PHP手册中说echo是语言结构，不是真正的函数，故把函数加上了双引号)。　　1、如果能将类的方法定义成static，就尽量定义成static，它的速度会提升将近4倍
• Yii框架中CGridView的使用方法以及详细示例 dcj3sjt126com yii
  CGridView显示一个数据项的列表中的一个表。 表中的每一行代表一个数据项的数据,和一个列通常代表一个属性的物品(一些列可能对应于复杂的表达式的属性或静态文本)。　　CGridView既支持排序和分页的数据项。排序和分页可以在AJAX模式或正常的页面请求。使用CGridView的一个好处是,当用户浏览器禁用JavaScript,排序和分页自动退化普通页面请求和仍然正常运行。 实例代码如下：
• Maven项目打包成可执行Jar文件 dyy_gusi assembly
  Maven项目打包成可执行Jar文件 在使用Maven完成项目以后，如果是需要打包成可执行的Jar文件，我们通过eclipse的导出很麻烦，还得指定入口文件的位置，还得说明依赖的jar包，既然都使用Maven了，很重要的一个目的就是让这些繁琐的操作简单。我们可以通过插件完成这项工作，使用assembly插件。具体使用方式如下： 1、在项目中加入插件的依赖： <plugin>
• php常见错误 geeksun PHP
  1.  kevent() reported that connect() failed (61: Connection refused) while connecting to upstream, client: 127.0.0.1, server: localhost, request: "GET / HTTP/1.1", upstream: "fastc
• 修改linux的用户名 hongtoushizi linuxchange password
  Change Linux Username 更改Linux用户名，需要修改4个系统的文件： /etc/passwd /etc/shadow /etc/group /etc/gshadow 古老/传统的方法是使用vi去直接修改，但是这有安全隐患（具体可自己搜一下），所以后来改成使用这些命令去代替： vipw vipw -s vigr vigr -s   具体的操作顺
• 第五章 常用Lua开发库1-redis、mysql、http客户端 jinnianshilongnian nginxlua
  对于开发来说需要有好的生态开发库来辅助我们快速开发，而Lua中也有大多数我们需要的第三方开发库如Redis、Memcached、Mysql、Http客户端、JSON、模板引擎等。 一些常见的Lua库可以在github上搜索，https://github.com/search?utf8=%E2%9C%93&q=lua+resty。   Redis客户端 lua-resty-r
• zkClient 监控机制实现 liyonghui160com zkClient 监控机制实现
           直接使用zk的api实现业务功能比较繁琐。因为要处理session loss，session expire等异常，在发生这些异常后进行重连。又因为ZK的watcher是一次性的，如果要基于wather实现发布/订阅模式，还要自己包装一下，将一次性订阅包装成持久订阅。另外如果要使用抽象级别更高的功能，比如分布式锁，leader选举
• 在Mysql 众多表中查找一个表名或者字段名的 SQL 语句 pda158 mysql
  在Mysql 众多表中查找一个表名或者字段名的 SQL 语句： 　　方法一：SELECT table_name, column_name from information_schema.columns WHERE column_name LIKE 'Name'; 　　方法二：SELECT column_name from information_schema.colum
• 程序员对英语的依赖 Smile.zeng 英语程序猿
  1、程序员最基本的技能，至少要能写得出代码，当我们还在为建立类的时候思考用什么单词发牢骚的时候，英语与别人的差距就直接表现出来咯。 2、程序员最起码能认识开发工具里的英语单词，不然怎么知道使用这些开发工具。 3、进阶一点，就是能读懂别人的代码，有利于我们学习人家的思路和技术。 4、写的程序至少能有一定的可读性，至少要人别人能懂吧... 以上一些问题，充分说明了英语对程序猿的重要性。骚年
• Oracle学习笔记(8) 使用PLSQL编写触发器 vipbooks oraclesql编程活动Access
      时间过得真快啊，转眼就到了Oracle学习笔记的最后个章节了，通过前面七章的学习大家应该对Oracle编程有了一定了了解了吧，这东东如果一段时间不用很快就会忘记了，所以我会把自己学习过的东西做好详细的笔记，用到的时候可以随时查找，马上上手！希望这些笔记能对大家有些帮助！     这是第八章的学习笔记，学习完第七章的子程序和包之后

按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他

首页 - 关于我们 - 站内搜索 - Sitemap - 侵权投诉

版权所有 IT知识库 CopyRight © 2000-2050 E-COM-NET.COM , All Rights Reserved.