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)

• Long类型前后端数据不一致 igotyback 前端
  响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
• LocalDateTime 转 String igotyback java开发语言
  importjava.time.LocalDateTime;importjava.time.format.DateTimeFormatter;publicclassMain{publicstaticvoidmain(String[]args){//获取当前时间LocalDateTimenow=LocalDateTime.now();//定义日期格式化器DateTimeFormatterformat
• Linux下QT开发的动态库界面弹出操作（SDL2） 13jjyao QT类qt开发语言sdl2linux
  需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
• 使用 FinalShell 进行远程连接（ssh 远程连接 Linux 服务器） 编程经验分享 开发工具服务器sshlinux
  目录前言基本使用教程新建远程连接连接主机自定义命令路由追踪前言后端开发，必然需要和服务器打交道，部署应用，排查问题，查看运行日志等等。一般服务器都是集中部署在机房中，也有一些直接是云服务器，总而言之，程序员不可能直接和服务器直接操作，一般都是通过ssh连接来登录服务器。刚接触远程连接时，使用的是XSHELL来远程连接服务器，连接上就能够操作远程服务器了，但是仅用XSHELL并没有上传下载文件的功能
• DIV+CSS+JavaScript技术制作网页（旅游主题网页设计与制作）云南大理 STU学生网页设计 网页设计期末网页作业html静态网页html5期末大作业网页设计web大作业
  ️精彩专栏推荐作者主页:【进入主页—获取更多源码】web前端期末大作业：【HTML5网页期末作业(1000套)】程序员有趣的告白方式：【HTML七夕情人节表白网页制作(110套)】文章目录二、网站介绍三、网站效果▶️1.视频演示2.图片演示四、网站代码HTML结构代码CSS样式代码五、更多源码二、网站介绍网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。网站程
• 【华为OD机试真题2023B卷 JAVA&JS】We Are A Team 若博豆 java算法华为javascript
  华为OD2023（B卷）机试题库全覆盖，刷题指南点这里WeAreATeam时间限制：1秒|内存限制：32768K|语言限制：不限题目描述：总共有n个人在机房，每个人有一个标号（1<=标号<=n），他们分成了多个团队，需要你根据收到的m条消息判定指定的两个人是否在一个团队中，具体的：1、消息构成为：abc，整数a、b分别代
• 关于城市旅游的HTML网页设计——(旅游风景云南 5页)HTML+CSS+JavaScript 二挡起步 web前端期末大作业javascripthtmlcss旅游风景
  ⛵源码获取文末联系✈Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业|游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作|HTML期末大学生网页设计作业，Web大学生网页HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScrip
• HTML网页设计制作大作业（div+css） 云南我的家乡旅游景点 带文字滚动 二挡起步 web前端期末大作业web设计网页规划与设计htmlcssjavascriptdreamweaver前端
  Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作HTML期末大学生网页设计作业HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScript：做与用户的交互行为文章目录前端学习路线
• node.js学习 小猿L node.jsnode.js学习vim
  node.js学习实操及笔记温故node.js，node.js学习实操过程及笔记~node.js学习视频node.js官网node.js中文网实操笔记githubcsdn笔记为什么学node.js可以让别人访问我们编写的网页为后续的框架学习打下基础，三大框架vuereactangular离不开node.jsnode.js是什么官网：node.js是一个开源的、跨平台的运行JavaScript的运行
• Low Power概念介绍-Voltage Area 飞奔的大虎
  随着智能手机，以及物联网的普及，芯片功耗的问题最近几年得到了越来越多的重视。为了实现集成电路的低功耗设计目标，我们需要在系统设计阶段就采用低功耗设计的方案。而且，随着设计流程的逐步推进，到了芯片后端设计阶段，降低芯片功耗的方法已经很少了，节省的功耗百分比也不断下降。芯片的功耗主要由静态功耗（staticleakagepower）和动态功耗(dynamicpower)构成。静态功耗主要是指电路处于等
• insert into select 主键自增_mybatis拦截器实现主键自动生成 weixin_39521651 insertintoselect主键自增mybatisdelete返回值mybatisinsert返回主键mybatisinsert返回对象mybatisplusinsert返回主键mybatisplus插入生成id
  前言前阵子和朋友聊天，他说他们项目有个需求，要实现主键自动生成，不想每次新增的时候，都手动设置主键。于是我就问他，那你们数据库表设置主键自动递增不就得了。他的回答是他们项目目前的id都是采用雪花算法来生成，因此为了项目稳定性，不会切换id的生成方式。朋友问我有没有什么实现思路，他们公司的orm框架是mybatis，我就建议他说，不然让你老大把mybatis切换成mybatis-plus。mybat
• Java 重写(Override)与重载(Overload) 叨唧唧的
  Java重写(Override)与重载(Overload)重写(Override)重写是子类对父类的允许访问的方法的实现过程进行重新编写,返回值和形参都不能改变。即外壳不变，核心重写！重写的好处在于子类可以根据需要，定义特定于自己的行为。也就是说子类能够根据需要实现父类的方法。重写方法不能抛出新的检查异常或者比被重写方法申明更加宽泛的异常。例如：父类的一个方法申明了一个检查异常IOExceptio
• 简单了解 JVM 记得开心一点啊 jvm
  目录♫什么是JVM♫JVM的运行流程♫JVM运行时数据区♪虚拟机栈♪本地方法栈♪堆♪程序计数器♪方法区/元数据区♫类加载的过程♫双亲委派模型♫垃圾回收机制♫什么是JVMJVM是JavaVirtualMachine的简称，意为Java虚拟机。虚拟机是指通过软件模拟的具有完整硬件功能的、运行在一个完全隔离的环境中的完整计算机系统（如：JVM、VMwave、VirtualBox）。JVM和其他两个虚拟机
• 1分钟解决 -bash: mvn: command not found，在Centos 7中安装Maven Energet!c 开发语言
  1分钟解决-bash:mvn:commandnotfound，在Centos7中安装Maven检查Java环境1下载Maven2解压Maven3配置环境变量4验证安装5常见问题与注意事项6总结检查Java环境Maven依赖Java环境，请确保系统已经安装了Java并配置了环境变量。可以通过以下命令检查：java-version如果未安装，请先安装Java。1下载Maven从官网下载：前往Apach
• Java企业面试题3 马龙强_ java
  1.break和continue的作用(智*图)break：用于完全退出一个循环（如for,while）或一个switch语句。当在循环体内遇到break语句时，程序会立即跳出当前循环体，继续执行循环之后的代码。continue：用于跳过当前循环体中剩余的部分，并开始下一次循环。如果是在for循环中使用continue，则会直接进行条件判断以决定是否执行下一轮循环。2.if分支语句和switch分
• JVM、JRE和 JDK：理解Java开发的三大核心组件 Y雨何时停T Javajava
  Java是一门跨平台的编程语言，它的成功离不开背后强大的运行环境与开发工具的支持。在Java的生态中，JVM（Java虚拟机）、JRE（Java运行时环境）和JDK（Java开发工具包）是三个至关重要的核心组件。本文将探讨JVM、JDK和JRE的区别，帮助你更好地理解Java的运行机制。1.JVM：Java虚拟机（JavaVirtualMachine）什么是JVM？JVM，即Java虚拟机，是Ja
• Java面试题精选：消息队列(二) 芒果不是芒 Java面试题精选javakafka
  一、Kafka的特性1.消息持久化：消息存储在磁盘，所以消息不会丢失2.高吞吐量：可以轻松实现单机百万级别的并发3.扩展性：扩展性强，还是动态扩展4.多客户端支持：支持多种语言（Java、C、C++、GO、）5.KafkaStreams（一个天生的流处理）:在双十一或者销售大屏就会用到这种流处理。使用KafkaStreams可以快速的把销售额统计出来6.安全机制：Kafka进行生产或者消费的时候会
• 白骑士的Java教学基础篇 2.5 控制流语句 白骑士所长 Java教学java开发语言
  欢迎继续学习Java编程的基础篇！在前面的章节中，我们了解了Java的变量、数据类型和运算符。接下来，我们将探讨Java中的控制流语句。控制流语句用于控制程序的执行顺序，使我们能够根据特定条件执行不同的代码块，或重复执行某段代码。这是编写复杂程序的基础。通过学习这一节内容，你将掌握如何使用条件语句和循环语句来编写更加灵活和高效的代码。条件语句条件语句用于根据条件的真假来执行不同的代码块。if语句‘
• python语法——三目运算符 HappyRocking pythonpython三目运算符
  在java中，有三目运算符，如：intc=(a>b)?a:b表示c取两者中的较大值。但是在python，不能直接这样使用，估计是因为冒号在python有分行的关键作用。那么在python中，如何实现类似功能呢？可以使用ifelse语句，也是一行可以完成，格式为：aifbelsec表示如果b为True，则表达式等于a，否则等于c。如：c=(aif(a>b)elseb)同样是完成了取最大值的功能。
• ArrayList 源码解析 程序猿进阶 Java基础ArrayListListjava面试性能优化架构设计idea
  ArrayList是Java集合框架中的一个动态数组实现，提供了可变大小的数组功能。它继承自AbstractList并实现了List接口，是顺序容器，即元素存放的数据与放进去的顺序相同，允许放入null元素，底层通过数组实现。除该类未实现同步外，其余跟Vector大致相同。每个ArrayList都有一个容量capacity，表示底层数组的实际大小，容器内存储元素的个数不能多于当前容量。当向容器中添
• Java爬虫框架（一）--架构设计 狼图腾-狼之传说 java框架java任务html解析器存储电子商务
  一、架构图那里搜网络爬虫框架主要针对电子商务网站进行数据爬取，分析，存储，索引。爬虫：爬虫负责爬取，解析，处理电子商务网站的网页的内容数据库：存储商品信息索引：商品的全文搜索索引Task队列：需要爬取的网页列表Visited表：已经爬取过的网页列表爬虫监控平台：web平台可以启动，停止爬虫，管理爬虫，task队列，visited表。二、爬虫1.流程1)Scheduler启动爬虫器，TaskMast
• Java：爬虫框架 dingcho Javajava爬虫
  一、ApacheNutch2【参考地址】Nutch是一个开源Java实现的搜索引擎。它提供了我们运行自己的搜索引擎所需的全部工具。包括全文搜索和Web爬虫。Nutch致力于让每个人能很容易,同时花费很少就可以配置世界一流的Web搜索引擎.为了完成这一宏伟的目标,Nutch必须能够做到:每个月取几十亿网页为这些网页维护一个索引对索引文件进行每秒上千次的搜索提供高质量的搜索结果简单来说Nutch支持分
• python怎么将png转为tif_png转tif weixin_39977276
  发国外的文章要求图片是tif，cmyk色彩空间的。大小尺寸还有要求。比如网上大神多，找到了一段代码，感谢！https://www.jianshu.com/p/ec2af4311f56https://github.com/KevinZc007/image2Tifimportjava.awt.image.BufferedImage;importjava.io.File;importjava.io.Fi
• springboot+vue项目实战一-创建SpringBoot简单项目 苹果酱0567 面试题汇总与解析springboot后端java中间件开发语言
  这段时间抽空给女朋友搭建一个个人博客，想着记录一下建站的过程，就当做笔记吧。虽然复制zjblog只要一个小时就可以搞定一个网站，或者用cms系统，三四个小时就可以做出一个前后台都有的网站，而且想做成啥样也都行。但是就是要从新做，自己做的意义不一样，更何况，俺就是专门干这个的，嘿嘿嘿要做一个网站，而且从零开始，首先呢就是技术选型了，经过一番思量决定选择-SpringBoot做后端，前端使用Vue做一
• JavaScript 中，深拷贝（Deep Copy）和浅拷贝（Shallow Copy） 跳房子的前端 前端面试javascript开发语言ecmascript
  在JavaScript中，深拷贝（DeepCopy）和浅拷贝（ShallowCopy）是用于复制对象或数组的两种不同方法。了解它们的区别和应用场景对于避免潜在的bugs和高效地处理数据非常重要。以下是对深拷贝和浅拷贝的详细解释，包括它们的概念、用途、优缺点以及实现方式。1.浅拷贝（ShallowCopy）概念定义：浅拷贝是指创建一个新的对象或数组，其中包含了原对象或数组的基本数据类型的值和对引用数
• uniapp map组件自定义markers标记点 以对_ uni-app学习记录uni-appjavascript前端
  需求是根据后端返回数据在地图上显示标记点，并且根据数据状态控制标记点颜色，标记点背景通过两张图片实现控制{{item.options.labelName}}exportdefault{data(){return{storeIndex:0,locaInfo:{longitude:120.445172,latitude:36.111387},markers:[//标点列表{id:1,//标记点idin
• JAVA·一个简单的登录窗口 MortalTom java开发语言学习
  文章目录概要整体架构流程技术名词解释技术细节资源概要JavaSwing是Java基础类库的一部分，主要用于开发图形用户界面（GUI）程序整体架构流程新建项目，导入sql.jar包（链接放在了文末），编译项目并运行技术名词解释一、特点丰富的组件提供了多种可视化组件，如按钮（JButton）、文本框（JTextField）、标签（JLabel）、下拉列表（JComboBox）等，可以满足不同的界面设计
• 笋丁网页自动回复机器人V3.0.0免授权版源码 希希分享 软希网58soho_cn源码资源笋丁网页自动回复机器人
  笋丁网页机器人一款可设置自动回复，默认消息，调用自定义api接口的网页机器人。此程序后端语言使用Golang，内存占用最高不超过30MB，1H1G服务器流畅运行。仅支持Linux服务器部署，不支持虚拟主机，请悉知！使用自定义api功能需要有一定的建站基础。源码下载：https://download.csdn.net/download/m0_66047725/89754250更多资源下载：关注我。安
• WebMagic：强大的Java爬虫框架解析与实战 Aaron_945 Javajava爬虫开发语言
  文章目录引言官网链接WebMagic原理概述基础使用1.添加依赖2.编写PageProcessor高级使用1.自定义Pipeline2.分布式抓取优点结论引言在大数据时代，网络爬虫作为数据收集的重要工具，扮演着不可或缺的角色。Java作为一门广泛使用的编程语言，在爬虫开发领域也有其独特的优势。WebMagic是一个开源的Java爬虫框架，它提供了简单灵活的API，支持多线程、分布式抓取，以及丰富的
• 博客网站制作教程 2401_85194651 javamaven
  首先就是技术框架：后端：Java+SpringBoot数据库：MySQL前端：Vue.js数据库连接：JPA(JavaPersistenceAPI)1.项目结构blog-app/├──backend/│├──src/main/java/com/example/blogapp/││├──BlogApplication.java││├──config/│││└──DatabaseConfig.java
• 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.