java复制代码@GetMapping("/pic")
public String showPic() {
    return "/qiqi.png";
}

arduino复制代码spring.mvc.static-path-pattern
spring.web.resources.static-locations

properties复制代码spring.mvc.static-path-pattern=/resources/**

java复制代码@GetMapping("/pic")
public String showPic() {
   return "/qiqi.png";
}

java复制代码@GetMapping("/pic")
public String showPic() {
   return "/resources/qiqi.png";
}

typescript复制代码classpath:/static,classpath:/public,classpath:/resources,classpath:/META-INF/resources

properties复制代码spring.web.resources.static-locations=classpath:/myRes

properties复制代码spring.web.resources.static-locations=file:res

java复制代码package com.example.resourcetest.config;

import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

/**
 * 自定义MVC配置器
 */
@Configuration
public class MyWebMvcConfig implements WebMvcConfigurer {

   /**
    * 重写资源路径配置
    */
   @Override
   public void addResourceHandlers(ResourceHandlerRegistry registry) {
      registry.addResourceHandler("/image/**").addResourceLocations("file:res/image/");
   }

}

java复制代码registry.addResourceHandler("/image/**").addResourceLocations("file:res/image/", "classpath:/static/");

java复制代码registry.addResourceHandler("/image/**", "/img/**").addResourceLocations("file:res/image/");

java复制代码package com.example.resourcetest.config;

import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

/**
 * 自定义MVC配置器
 */
@Configuration
public class MyWebMvcConfig implements WebMvcConfigurer {

   /**
    * 重写资源路径配置
    */
   @Override
   public void addResourceHandlers(ResourceHandlerRegistry registry) {
      // 访问/image/xxx对应去res/image查找资源
      registry.addResourceHandler("/image/**").addResourceLocations("file:res/image/");
      // 访问/web/xxx对应去res/web下查找资源
      registry.addResourceHandler("/web/**").addResourceLocations("file:res/web/");
   }

}

java复制代码@GetMapping("/rabbit-halloween")
public String image() {
   return "/image/gz-12.png";
}

java复制代码@PropertySource(value={"自定义配置文件路径"})

java复制代码@PropertySource(value={"配置1路径", "配置2路径"})

java复制代码package com.example.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.PropertySource;

@SpringBootApplication
@PropertySource(value={"file:self.properties"})
public class DemoApplication {

   public static void main(String[] args) {
      SpringApplication.run(DemoApplication.class, args);
   }

}

matlab复制代码application.properties
application-dev.properties
application-prod.properties

properties复制代码# 指定当前使用开发环境配置文件
spring.profiles.active=dev

matlab复制代码application-环境配置名.properties

properties复制代码spring.profiles.active=环境配置名

makefile复制代码file:./config/
file:./
classpath:/config/
classpath:/

java复制代码// 扫描项目文件夹（jar运行目录）中Resources/config目录中所有的配置文件
System.setProperty("spring.config.location", "file:Resources/config/");

// 扫描项目文件夹（jar运行目录）中Resources/config/app.properties文件
System.setProperty("spring.config.location", "file:Resources/config/app.properties");

// 扫描项目文件夹（jar运行目录）中Resources/config目录和Resources/config2目录中所有的配置文件
System.setProperty("spring.config.location", "file:Resources/config/, file:Resources/config2/");

java复制代码package com.gitee.swsk33.test;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class TestApplication {

   public static void main(String[] args) {
      // 设定配置文件扫描目录
      System.setProperty("spring.config.location", "file:Resources/config/");
      SpringApplication.run(TestApplication.class, args);
   }

}

properties复制代码spring.profiles.active=dev

java复制代码System.setProperty("spring.config.name", "config");

arduino复制代码config-dev.properties
config-prod.properties

sql复制代码>HSET user:199929 sex m
>HSET user:199929 age 22
>HGETALL user:199929
1) "sex"
2) "m"
3) "age"
4) "22"

sql复制代码> INCRBY feed:e3kk38j4kl:like 1
> INCRBY feed:e3kk38j4kl:like 1
> GET feed:e3kk38j4kl:like
"2"

python复制代码>ZADD sorted:xjjdog:2021-07  55 dog0
>ZADD sorted:xjjdog:2021-07  89 dog1
>ZADD sorted:xjjdog:2021-07  32 dog2
>ZCARD sorted:xjjdog:2021-07
>3
> ZREVRANGE  sorted:xjjdog:2021-07  0 -10 WITHSCORES # top10排行榜
1) "dog1"
2) "89"
3) "dog0"
4) "55"
5) "dog2"
6) "32"

shell复制代码>SETBIT online:2021-07-23 3876520333 1
>SETBIT online:2021-07-24 3876520333 1
>GETBIT online:2021-07-23 3876520333
1
>BITOP AND active online:2021-07-23 online:2021-07-24
>GETBIT active 3876520333
1
>DEBUG OBJECT online:2021-07-23
Value at:0x7fdfde438bf0 refcount:1 encoding:raw serializedlength:5506446 lru:16410558 lru_seconds_idle:5
(0.96s)

typescript复制代码public String lock(String key, int timeOutSecond) {
    for (; ; ) {
        String stamp = String.valueOf(System.nanoTime());
        boolean exist = redisTemplate.opsForValue().setIfAbsent(key, stamp, timeOutSecond, TimeUnit.SECONDS);
        if (exist) {
            return stamp;
        }
    }
}
public void unlock(String key, String stamp) {
    redisTemplate.execute(script, Arrays.asList(key), stamp);
}

sql复制代码local stamp = ARGV[1]
local key = KEYS[1]
local current = redis.call("GET",key)
if stamp == current then
    redis.call("DEL",key)
    return "OK"
end

vbnet复制代码 incr key
 expire key 1

ini复制代码 RRateLimiter limiter = redisson.getRateLimiter("xjjdogLimiter");
 // 只需要初始化一次
 // 每2秒钟5个许可
 limiter.trySetRate(RateType.OVERALL, 5, 2, RateIntervalUnit.SECONDS);
 
 // 没有可用的许可，将一直阻塞    
 limiter.acquire(3);

xml复制代码<dependency>
  <groupId>com.github.pagehelper</groupId>
  <artifactId>pagehelper-spring-boot-starter</artifactId>
  <version>1.4.6</version>
</dependency>

xml复制代码<select id="getAll" resultMap="userResultMap">
    select * from `user`
</select>

java复制代码/**
 * 获取全部用户
 */
List<User> getAll();

java复制代码@Autowired
private UserDAO userDAO;
 
/**
 * 查询用户
 *
 * @param pageNum  当前页码
 * @param pageSize 一页的记录数
 */
public Page<User> getUserList(int currentPage, int pageSize) {
	Page<User> userPage = PageHelper.startPage(currentPage, pageSize).doSelectPage(() -> userDAO.getAll());
	return userPage;
}

java复制代码//查询第一页数据，每一页15条记录
userService.getUserList(1, 15).getResult();

java复制代码import com.github.pagehelper.Page;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;
 
import java.io.Serializable;
import java.util.List;
 
/**
 * 分页查询结果模型，存放整个结果分页基本信息和当前页信息以及内容
 */
@Setter
@Getter
@NoArgsConstructor
public class Paging<T> implements Serializable {
 
	/**
	 * 当前页
	 */
	private int currentPageNum;
 
	/**
	 * 总页数
	 */
	private int totalPageNum;
 
	/**
	 * 每页记录数量
	 */
	private int pageSize;
 
	/**
	 * 总记录数
	 */
	private long totalCount;
 
	/**
	 * 当前页记录集合
	 */
	List<T> dataCurrentPage;
 
	/**
	 * 传入Page结果对象构造Pageing对象
	 *
	 * @param pageResult 分页查询结果Page对象
	 */
	public Paging(Page<T> pageResult) {
		this.currentPageNum = pageResult.getPageNum();
		this.totalPageNum = pageResult.getPages();
		this.totalCount = pageResult.getTotal();
		this.pageSize = pageResult.getPageSize();
		this.dataCurrentPage = pageResult.getResult();
	}
 
}

java复制代码@Autowired
private UserDAO userDAO;
 
/**
 * 查询用户
 *
 * @param pageNum  当前页码
 * @param pageSize 一页的记录数
 */
public Paging<User> getUserList(int currentPage, int pageSize) {
	Page<User> userPage = PageHelper.startPage(currentPage, pageSize).doSelectPage(() -> userDAO.getAll());
	Paging<User> userPaging = new Paging<User>(userPage);
	return userPaging;
}

go复制代码package main
import(
	"fmt"
    "crypto/md5"
    "encoding/hex"
)
func main(){
    //方法一
    data:=[]byte("hello world")
    s:=fmt.Sprintf("%x",md5.Sum(data))
    fmt.Println(s)
    //方法二
    h:=md5.New()
    h.Write(data)
    s= hex.EncodeToString(h.Sum(nil))
    fmt.Println(s)
}

go复制代码package main
import(
	"fmt"
    "github.com/nebulasio/go-nebulas/crypto/hash"
    "encoding/hex"
	"crypto/sha256"    
)

func main(){
    //方法一 一个方法直接输出
    data:=[]byte("hello world")
    hash:=hash.Sha256(data)
    fmt.Println(hex.EncodeToString(hash))
    sha256.New()
    //方法二 按照步骤一步一步输出
    h:= sha256.New() //创建sha256算法
    h.Write(data)  //用sha256算法对参数a进行加密，得到8个变量
    hashTemp := h.Sum(nil)//将8个变量相加得到最终hash
    fmt.Println(hex.EncodeToString(hashTemp))
}

go复制代码/*
1.定义一个区块的结构Block
a.区块头：6个字段
b.区块体：字符串表示data
*/
//区块
type Block struct {
   Version int64   //版本
   PerBlockHash []byte //前一个区块的hash值
   Hash []byte //当前区块的hash值，是为了简化代码
   MerKelRoot []byte  //梅克尔根
   TimeStamp int64  //时间抽
   Bits int64  //难度值
   Nonce int64 //随机值

//区块体
   Data []byte  //交易信息
}

go复制代码提供一个创建区块的方法
NewBlock(参数)
*/
func NewBlock(data string ,prevBlockHash []byte) *Block {
   var block Block
   block = Block{
      Version:      2,
      PerBlockHash: prevBlockHash,
      //Hash:         []byte{},      //区块不存储hash值，节点接受区块后独立计算并存储在本地。
      MerKelRoot:   []byte{},
      TimeStamp:    time.Now().Unix(),
      Bits:         targetBits,
      Nonce:        0,
      Data:         []byte(data),
   }
   // block.SetHash()  //填充Hash
   PoW:= NewProofOfWork(&block)
   nonce , hash :=PoW.Run()
   block.Nonce=nonce
   block.Hash=hash
   return &block
}

go复制代码func NewGensisBlock() *Block{
   return NewBlock("Genesis Block!",[]byte{})
}

go复制代码/*
3. 定义一个工作量证明的结构ProofOfWork
block
目标值
*/
type ProofOfWork struct {
   block *Block
   target *big.Int   //目标值
}

go复制代码/*
4. 提供一个创造PoW的方法
NewProofOfWork(参数)
*/
const targetBits = 24 
func NewProofOfWork(block *Block) *ProofOfWork {  //工作量证明
   target := big.NewInt(1)  //000....001
   target.Lsh(target,uint(256-targetBits))  //将1向左移动 //ox00000010000000..00
   pow:=ProofOfWork{
      block:  block,
      target: target,
   }
   return &pow
}

func (pow *ProofOfWork) PrepareData(nonce int64) []byte {
   // 源码里面是要传二维切片 func Join(s [][]byte, sep []byte) []byte
   block := pow.block
   tmp :=[][]byte{
      IntToByte(block.Version),
      block.PerBlockHash,
      block.MerKelRoot,
      IntToByte(block.TimeStamp),
      IntToByte(block.Bits),
      IntToByte(block.Nonce),
   }
   data:=bytes.Join(tmp,[]byte{})    //之后再计算hash
   return data
}

go复制代码/*
5. 提供一个计算哈希值的方法
Run()
*/

func (pow *ProofOfWork)Run() (int64,[]byte) {
   //1.凭借数据
   //2.哈希值转成big.Int类型
   var hash [32]byte
   var nonce int64 = 0
   var hashInt big.Int
   fmt.Println("开始挖矿了！")
   fmt.Printf("难度 target hash : %x\n" ,pow.target.Bytes())
   for nonce < math.MaxInt64  {
      data:=pow.PrepareData(nonce)
      hash = sha256.Sum256(data)
      // Cmp compares x and y and returns:
      //
      //   -1 if x <  y
      //    0 if x == y
      //   +1 if x >  y
      //
      hashInt.SetBytes(hash[:])
      if hashInt.Cmp(pow.target) == -1 {
         fmt.Printf("Found ,nonce :%d ,hash :%x \n",nonce,hash)
      }else {
         //fmt.Printf("Not Found ,current nonce :%d ,hash :%x \n",nonce,hash)
         nonce++
      }
   }
   return nonce,hash[:]
}

go复制代码/*
6. 提供一个校验函数
IsValid()
*/

func (pow *ProofOfWork)IsValid() bool{
   var hashInt big.Int
   data := pow.PrepareData(pow.block.Nonce)
   hash:=sha256.Sum256(data)
   hashInt.SetBytes(hash[:])
   return hashInt.Cmp(pow.target) == -1  		//如果是-1就是找到了就是

}

go复制代码/*
1. 定义一个区块链结构BlockChain
​   Block数组
*/
type BlockChain struct {
	blocks []*Block
}

go复制代码/*
2. 提供一个创建BlockChain()的方法
​   NewBlockChain()
*/
func NewBlockChain() *BlockChain {
	block := NewGensisBlock()
	return &BlockChain{blocks:[]*Block{block}} 		 //创建只有一个元素的区块链，初始化
}

go复制代码/*
3. 提供一个添加区块的方法
​   AddBlock(参数)
*/
func (bc *BlockChain)AddBlock(data string)  {
	PerBlockHash := bc.blocks[len(bc.blocks)-1].Hash  	//这一个区块的哈希是前一块的哈希值
	block := NewBlock(data,PerBlockHash)
	bc.blocks = append(bc.blocks,block)
}

markdown复制代码	MyBatis 是一个优秀的基于 java 的持久层框架，内部封装了 jdbc，开发者只需要关注 sql 语句本身，而不需要处理加载驱动、创建连接、创建 statement、关闭连接，资源等繁杂的过程。
	MyBatis 通过 xml 或注解两种方式将要执行的各种 sql 语句配置起来，并通过 java 对象和 sql 的动态参数进行映射生成最终执行的 sql 语句，最后由 mybatis 框架执行 sql 并将结果映射为 java对象并返回。

markdown复制代码	Spring 框架为了解决软件开发的复杂性而创建的。Spring 使用的是基本的 JavaBean 来完成以前非常复杂的企业级开发。Spring 解决了业务对象，功能模块之间的耦合，不仅在 javase,web 中使用，大部分 Java 应用都可以从 Spring 中受益。
	Spring 是一个轻量级控制反转(IoC)和面向切面(AOP)的容器。

markdown复制代码	Spring MVC 属于 SpringFrameWork 3.0 版本加入的一个模块，为 Spring 框架提供了构建 Web应用程序的能力。现在可以 Spring 框架提供的 SpringMVC 模块实现 web 应用开发，在 web 项目中可以无缝使用 Spring 和 Spring MVC 框架

java复制代码public void findStudent() {
    Connection conn = null;
    Statement stmt = null;
    ResultSet rs = null;
try {
    //注册 mysql 驱动
    Class.forName("com.mysql.jdbc.Driver");
    //连接数据的基本信息 url ，username，password
    String url = "jdbc:mysql://localhost:3306/springdb";
    String username = "root";
    String password = "123456";
    //创建连接对象
    conn = DriverManager.getConnection(url, username, password);
    //保存查询结果
    List<Student> stuList = new ArrayList<>();
    //创建 Statement, 用来执行 sql 语句
    stmt = conn.createStatement();
    //执行查询，创建记录集，
    rs = stmt.executeQuery("select * from student");
    while (rs.next()) {
        Student stu = new Student();
        stu.setId(rs.getInt("id"));
        stu.setName(rs.getString("name"));
        stu.setAge(rs.getInt("age"));
   		//从数据库取出数据转为 Student 对象，封装到 List 集合
    	stuList.add(stu);
}
    } catch (Exception e) {
		e.printStackTrace();
} finally {
	try {
		//关闭资源
		if (rs != null) ;
		{
			rs.close();
		}
		if (stmt != null) {
			stmt.close();
		}
		if (conn != null) {
			conn.close();
		}
	} catch (Exception e) {
			e.printStackTrace();
		}
	}
}

markdown复制代码myBatis-3.4.1.jar
mysql-connector-java-5.1.37-bin.jar
log4j.jar

xml复制代码<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE log4j:configuration SYSTEM "log4j.dtd">

<log4j:configuration xmlns:log4j="http://jakarta.apache.org/log4j/">

<appender name="STDOUT" class="org.apache.log4j.ConsoleAppender">
<param name="Encoding" value="UTF-8" />
<layout class="org.apache.log4j.PatternLayout">
<param name="ConversionPattern" value="%-5p %d{MM-dd HH:mm:ss,SSS} %m (%F:%L) \n" />
</layout>
</appender>
<logger name="java.sql">
<level value="debug" />
</logger>
    <logger name="org.apache.ibatis">
<level value="info" />
</logger>
<root>
<level value="debug" />
<appender-ref ref="STDOUT" />
</root>
</log4j:configuration>

mysql复制代码-- 创建库
CREATE DATABASE test_mybatis;
-- 使用库
USE test_mybatis;
-- 创建表
CREATE TABLE user(
id INT(11) PRIMARY KEY AUTO_INCREMENT,
username VARCHAR(50),
pwd VARCHAR(50),
);

java复制代码package com.domain;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

/**
 * @author Xiao_Lin
 * @date 2021/1/5 11:33
 */
@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {
  private Integer id;
  private String username;
  private String pwd;
}

xml复制代码<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
	PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
	"http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
	<!--配置 mybatis 环境-->
	<environments default="mysql">
		<!--id:数据源的名称-->
		<environment id="mysql">
		<!--配置事务类型：使用 JDBC 事务（使用 Connection 的提交和回滚）-->
			<transactionManager type="JDBC"/>
			<!--数据源 dataSource：创建数据库 Connection 对象
			type: POOLED 使用数据库的连接池
			-->
                <dataSource type="POOLED">
                    <!--连接数据库的四个要素-->
                    <property name="driver" value="com.mysql.jdbc.Driver"/>
                    <property name="url" value="jdbc:mysql:///javaweb?characterEncoding=utf-8&amp;useSSL=false"/>
                    <property name="username" value="root"/>
                    <property name="password" value="1101121833"/>
                </dataSource>
		</environment>
	</environments>
	<mappers>
		<!--告诉 mybatis 要执行的 sql 语句的位置,写的路径是字节码输出路径-->
		<mapper resource="com/dao/StudentDao.xml"/>
	</mappers>
</configuration>

java复制代码public interface UserDao {
	/*查询所有数据*/
	List<User> selectAll();
}

xml复制代码<?xml version="1.0" encoding="utf-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
  "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
    <!--
      用来存储SQL语句的
      namespace属性里面必须写 用来书写当前的mapper是对哪个DAO接口的实现
      他的意思是表示该配置文件的唯一标识，意味着不同的XxxMapper.xml文件的namespace的值时不同的
      -->

    <!--
      select标签表示查询操作，
     	  id属性表示在mapper配置文件中是唯一标识，一般使用方法名作为其值。
     	  paraType属性表示传入参数的类型，可省略不写，底层使用了反射，根据传入参数得到对象的类型		   标签体中编写sql语句，#{变量},#表示占位符，和jdbc的?一样。
          如果传入的参数是简单类型（包括String）,那么该类型可以任意写
          如果传入的参数是对象类型，那么变量的名称必须使用对象对应的类中的属性
		  resultType: 查询语句的返回结果数据类型，使用全限定类名
      -->

<mapper namespace="com.mapper.UserDao">
  <select id="selectAll" resultType="com.domain.User">
    select * from user
  </select>
</mapper>

java复制代码<settings>
	<setting name="logImpl" value="STDOUT_LOGGING" />
</settings>

java复制代码public class test {
        /*
		* mybatis 入门
		*/
	@Test
	public void testStart() throws IOException {
		//1.mybatis 主配置文件
		String config = "mybatis-config.xml";
		//2.读取配置文件
		InputStream in = Resources.getResourceAsStream(config);
		//3.创建 SqlSessionFactory 对象,目的是获取 SqlSession
		SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(in);
		//4.获取 SqlSession,SqlSession 能执行 sql 语句
		SqlSession session = factory.openSession();
		//5.执行 SqlSession 的 selectList()
		List<User> users = session.selectList("com.dao.UserDao.selectAll");
		//6.循环输出查询结果
		studentList.forEach( u -> System.out.println(u));
		//7.关闭 SqlSession，释放资源
		session.close();
    }
}

java复制代码int insertUser(User user);

xml复制代码<insert id="insertUser">
insert into user(id,username,pwd) values(#{id},#{username},#{pwd})
</insert>

java复制代码@Test
public void testInsert() throws IOException {
	//1.mybatis 主配置文件
	String config = "mybatis-config.xml";
	//2.读取配置文件
	InputStream in = Resources.getResourceAsStream(config);
	//3.创建 SqlSessionFactory 对象
	SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(in);
	//4.获取 SqlSession
	SqlSession session = factory.openSession();
	//5.创建保存数据的对象
	User user = new User();
	user.setId(1005);
	user.setUsername("张三");
	user.setPwd("123456");
	//6.执行插入 insert
	int rows = session.insert("com.dao.UserDao.insertUser",student);
	//7.提交事务
	session.commit();
	System.out.println("增加记录的行数:"+rows);
	//8.关闭 SqlSession
	session.close();
}

java复制代码int updateUser(User user);

mysql复制代码<update id="updateUser">
	update user set username = #{username} where id = #{id}
</update>

java复制代码@Test
public void testUpdate() throws IOException {
	//1.mybatis 主配置文件
	String config = "mybatis-config.xml";
	//2.读取配置文件
	InputStream in = Resources.getResourceAsStream(config);
	//3.创建 SqlSessionFactory 对象
	SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(in);
	//4.获取 SqlSession
	SqlSession session = factory.openSession();
	//5.创建保存数据的对象
	User user = new User();
	user.setId(1005);//要修改的 id
	user.setUsername("李四"); //要修改的年龄值
	//6.执行更新 update
	int rows = session.update("com.dao.UserDao.updateUser",user);
	//7.提交事务
	session.commit();
	System.out.println("修改记录的行数:"+rows);
	//8.关闭 SqlSession
	session.close();
}

java复制代码int deleteUser(int id);

java复制代码<delete id="deleteUser">
	delete from user where id=#{id}
</delete>

java复制代码@Test
public void testUpdate() throws IOException {
	//1.mybatis 主配置文件
	String config = "mybatis-config.xml";
	//2.读取配置文件
	InputStream in = Resources.getResourceAsStream(config);
	//3.创建 SqlSessionFactory 对象
	SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(in);
	//4.获取 SqlSession
	SqlSession session = factory.openSession();
	//5.删除的 id
	int id = 1001;
	//6.执行删除 delete
	int rows = session.delete("com.dao.UserDao.deleteStudent",id);
	//7.提交事务
	session.commit();
	System.out.println("修改记录的行数:"+rows);
	//8.关闭 SqlSession
	session.close();
}

java复制代码public class MyBatisUtil {
	//定义 SqlSessionFactory
	private static SqlSessionFactory factory = null;
	static {
	//使用 静态块 创建一次 SqlSessionFactory
	try{
		String config = "mybatis-config.xml";
		//读取配置文件
		InputStream in = Resources.getResourceAsStream(config);
		//创建 SqlSessionFactory 对象
		factory = new SqlSessionFactoryBuilder().build(in);
	}catch (Exception e){
		factory = null;
	e.printStackTrace();
	}
}
	/* 获取 SqlSession 对象 */
	public static SqlSession getSqlSession(){
		SqlSession session = null;
		if( factory != null){
			session = factory.openSession();
		}
		return session;
	}
}

markdown复制代码configuration 配置
	properties 属性
	settings 设置
	typeAliases 类型命名
	typeHandlers 类型处理器
	objectFactory 对象工厂
	plugins 插件
	environments 环境
		environment 环境变量
			transactionManager 事务管理器
			dataSource 数据源
	databaseIdProvider 数据库厂商标识
mappers 映射器

xml复制代码<properties>
	<!--驱动名（MySQL5 和MySQL8 不同）-->
	<property name="driver" value="com.mysql.jdbc.Driver" />
	<!--url名字（MySQL5 和MySQL8 不同）-->
	<property name="url"
		<value="jdbc:mysql://localhost:3306/javaweb" />
	<property name="username" value="root" />
	<property name="password" value="123456" />
</properties>

properties复制代码jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/javaweb
jdbc.username=root
jdbc.password=123456

xml复制代码<!--

properties: 引入外部的属性文件
resource: 从类路径下引入属性文件
url: 引入网络路径或者是磁盘路径下的属性文件

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

xml复制代码<environments default="mysql">
	<environment id="mysql">
	<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>

xml复制代码<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>

xml复制代码<typeAliases>
	<typeAlias type="com.domain.User" alias="user"/>
</typeAliases>

xml复制代码<typeAliases>
	<package name="com.domain.User"/>
</typeAliases>

xml复制代码<environments default="mysql">
	<environment id="mysql">
		<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>
	<environment id="oracle">
		<transactionManager type="JDBC"/>
		<dataSource type="POOLED">
			<property name="driver" value="${orcl.driver}" />
			<property name="url" value="${orcl.url}" />
			<property name="username" value="${orcl.username}" />
			<property name="password" value="${orcl.password}" />
		</dataSource>
	</environment>
   </environments>

xml复制代码<databaseIdProvider type="DB_VENDOR">
	<property name="MySQL" value="mysql"/>
	<property name="Oracle" value="oracle"/>
</databaseIdProvider>

xml复制代码<select id="getEmployeeById" resultType="com.atguigu.mybatis.beans.Employee" databaseId="mysql">
	select * from tbl_employee where id = #{id}
</select>

xml复制代码<mappers>
	<mapper resource="EmployeeMapper.xml" />
	<mapper class="com.dao.EmployeeMapper"/>
	<package name="com.dao.mybatis.dao"/>
</mappers>

xml复制代码<mappers>
	<package name="com.dao"/>
</mappers>

markdown复制代码cache – 给定命名空间的缓存配置。
cache-ref – 其他命名空间缓存配置的引用。
resultMap – 是最复杂也是最强大的元素，用来描述如何从数据库结果集中来加载对象。
parameterMap – 已废弃！
sql – 可被其他语句引用的可重用语句块。
insert – 映射插入语句
update – 映射更新语句
delete – 映射删除语句
select – 映射查询语

java复制代码SqlSession session = factory.openSession();
UserDao dao = session.getMapper(UserDao.class);

//或者可以使用工具类
UserDao userDao =
MyBatisUtil.getSqlSession().getMapper(UserDao.class);

java复制代码  @Test
  public void TestUpdate(){
    User user = new User(16,"赵六","110");
    userDao.update(user);
  }

ini复制代码若数据库支持自动生成主键的字段（比如 MySQL 和 SQL Server ），则可以设置`useGeneratedKeys=”true”`，然后再把 keyProperty 设置到目标属性上。

xml复制代码<insert id="insertEmployee"
insert id="insertEmployee"parameterType="com.atguigu.mybatis.beans.Employee" databaseId="mysql" useGeneratedKeys="true" keyProperty="id">
			insert into tbl_employee(last_name,email,gender) values(#{lastName},#{email},#{gender})
</insert>

xml复制代码<insert id="insertEmployee" parameterType="com.atguigu.mybatis.beans.Employee" databaseId="oracle">
    <selectKey order="BEFORE" keyProperty="id" resultType="integer">
		select employee_seq.nextval from dual
	</selectKey>
    insert into orcl_employee(id,last_name,email,gender) values(#{id},#{lastName},#{email},#{gender})
</insert>

xml复制代码<insert id="insertEmployee" parameterType="com.atguigu.mybatis.beans.Employee" databaseId="oracle">
	<selectKey order="AFTER" keyProperty="id" resultType="integer">
		select employee_seq.currval from dual
	</selectKey>
	insert into orcl_employee(id,last_name,email,gender) values(employee_seq.nextval,#{lastName},#{email},#{gender})
</insert>

java复制代码//接口中的方法：
User selectById(int id);

xml复制代码<!--mapper文件-->
<select id="selectById" resultType="com.bjpowernode.domain.Student">
	select id,username,pwd from user where id=#{abcd}
</select>
<!--
	#{abcd} , abcd是自定义的变量名称，可以不和方法参数名相同，但是实际开发中一般是相同的。
-->

java复制代码//接口方法
List<User> selectUserByCondition(@Param("username") String username, @Param("pwd") int pwd);

xml复制代码<!--mapper文件-->
<select id="selectUserByCondition" resultType="com.domain.User">
	select id,username,pwd from student where username = #{username} or pwd = #{pwd}
</select>

java复制代码//接口方法
List<User> selectMultiMap(Map<String,Object> map);

xml复制代码<!--mapper文件-->
<select id="selectMultiMap" resultType="com.domain.User">
	select id,username,pwd from user where username=#{username} or pwd =#{pwd}
</select>

java复制代码public User getUserByIdAndUsername
(@Param("id")Integer id, @Param("username")String username);

java复制代码    public Object getNamedParams(Object[] args) {
        final int paramCount = names.size();
        if (args == null || paramCount == 0) {
            return null;
        } else if (!hasParamAnnotation && paramCount == 1) {
            return args[names.firstKey()];
        } else {
            final Map<String, Object> param = new ParamMap<Object>();
            int i = 0;
            for (Map.Entry<Integer, String> entry : names.entrySet()) {
                param.put(entry.getValue(), args[entry.getKey()]);
				// add generic param names (param1, param2, ...)
                final String genericParamName = GENERIC_NAME_PREFIX +
                        String.valueOf(i + 1);
				// ensure not to overwrite parameter named with @Param
                if (!names.containsValue(genericParamName)) {
                    param.put(genericParamName, args[entry.getKey()]);
                }
                i++;
            }
            return param;
        }
    }

xml复制代码<select id="selectMultiObject" resultType="com.domain.User">
select id,username pwd from user
where username=#{username,javaType=string,jdbcType=VARCHAR}
or pwd =#{pwd,javaType=int,jdbcType=INTEGER}
</select>

xml复制代码<!--mapper文件-->
<select id="selectById" resultType="com.domain.User">
select id,username,pwd from user where id=#{id}
</select>

java复制代码//转为 MyBatis 的执行是：
String sql=” select id,username,pwd from user where id=?”;
PreparedStatement ps = conn.prepareStatement(sql);
ps.setInt(1,1005);

//解释：
where id=? 就是 where id=#{id}
ps.setInt(1,1005) , 1005 会替换掉 #{id}

java复制代码//需求：使用不同列作为查询条件
//接口方法
User findByDiffField(@Param("col") String colunName,@Param("cval") Object value);

xml复制代码<!--mapper文件-->
<select id="findByDiffField" resultType="com.domain.User">
select * from user where ${col} = #{cval}
</select>

java复制代码public User getUserById(Integer id );

java复制代码public List<User> getAllUser();

java复制代码public Map<String,Object> getUserByIdReturnMap(Integer id );

java复制代码@MapKey("id") // 指定使用对象的哪个属性来充当 map 的 key
public Map<Integer,User> getAllUserReturnMap();

java复制代码//接口方法
int countUser();

xml复制代码<!--mapper 文件-->
<select id="countUser" resultType="int">
	select count(*) from user
</select>

java复制代码//接口方法
List<User> selectUsers();

xml复制代码<!--mapper文件-->
<select id="selectUsers" resultType="com.domain.User">
	select id,username,pwd from user 
</select>

xml复制代码<!--resultMap: resultMap 标签中的 id 属性值-->
<select id="getEmployeeById" resultMap="myEmp">
	select id, last_name,email, gender from tbl_employee where id =#{id}
</select>

    <!-- 创建 resultMap
    id:自定义的唯一名称，在<select>使用
    type:期望转为的 java 对象的全限定名称或别名
    -->
<resultMap type="com.domain.Employee" id="myEmp">
    <!-- 主键字段使用 id -->
	<id column="id" property="id" />
    <!--非主键字段使用 result-->
	<result column="last_name" property="lastName"/>
	<result column="email" property="email"/>
	<result column="gender" property="gender"/>
</resultMap>

java复制代码@Data
public class Department {
	private Integer id ;
	private String departmentName ;
}

java复制代码@Data
public class Employee {
	private Integer id ;
	private String lastName;
	private String email ;
	private String gender ;
	private Department dept ;

}

xml复制代码<select id="getEmployeeAndDept" resultMap="myEmpAndDept" >
	SELECT e.id eid, e.last_name, e.email,e.gender ,d.id did, d.dept_name 
    FROM tbl_employee e , tbl_dept d 
    WHERE e.d_id = d.id 
    AND e.id = #{id}
</select>
<resultMap type="com.domain.Employee" id="myEmpAndDept">
	<id column="eid" property="id"/>
	<result column="last_name" property="lastName"/>
	<result column="email" property="email"/>
	<result column="gender" property="gender"/>
	<association property="dept" javaType="com.domain.Department">
		<id column="did" property="id"/>
		<result column="dept_name" property="departmentName"/>
		</association>
</resultMap>

xml复制代码<select id="getEmployeeAndDeptStep" resultMap="myEmpAndDeptStep">
	select id, last_name, email,gender,d_id from tbl_employee where id =#{id}
</select>
	<resultMap type="com.atguigu.mybatis.beans.Employee" id="myEmpAndDeptStep">
		<id column="id" property="id" />
		<result column="last_name" property="lastName"/>
		<result column="email" property="email"/>
		<result column="gender" property="gender"/>
		<association property="dept" 
                     select="com.atguigu.mybatis.dao.DepartmentMapper.getDeptById" 
                     column="d_id" 
                     fetchType="eager">
		</association>
</resultMap>

xml复制代码<!-- 开启延迟加载 -->
<setting name="lazyLoadingEnabled" value="true"/>
<!-- 设置加载的数据是按需还是全部 -->
<setting name="aggressiveLazyLoading" value="false"/>

java复制代码@Data
public class Department {
	private Integer id ;
	private String departmentName ;
	private List<Employee> emps ;
}

xml复制代码<select id="getDeptAndEmpsById" resultMap="myDeptAndEmps">
	SELECT d.id did, d.dept_name ,e.id eid ,e.last_name ,e.email,e.gender
	FROM tbl_dept d 
	LEFT OUTER JOIN tbl_employee e 
	ON d.id = e.d_id
	WHERE d.id = #{id}
</select>
<resultMap type="com.atguigu.mybatis.beans.Department" id="myDeptAndEmps">
	<id column="did" property="id"/>
	<result column="dept_name" property="departmentName"/>
        <!--
        property: 关联的属性名
        ofType: 集合中元素的类型
        -->
		<collection property="emps" ofType="com.atguigu.mybatis.beans.Employee">
			<id column="eid" property="id"/>
			<result column="last_name" property="lastName"/>
			<result column="email" property="email"/>
			<result column="gender" property="gender"/>
		</collection>
</resultMap>

xml复制代码<select id="getDeptAndEmpsByIdStep" resultMap="myDeptAndEmpsStep">
	select id ,dept_name from tbl_dept where id = #{id}
</select>
	<resultMap type="com.atguigu.mybatis.beans.Department" id="myDeptAndEmpsStep">
		<id column="id" property="id"/>
		<result column="dept_name" property="departmentName"/>
		<collection property="emps" select="com.atguigu.mybatis.dao.EmployeeMapper.getEmpsByDid" column="id"></collection>
	</resultMap>

java复制代码//接口方法
List<User> selectLikeFirst(String username);

xml复制代码<!--接口文件-->
<select id="selectLikeFirst" resultType="com.domain.User">
select id,username,pwd from user where username like #{username}
</select>

java复制代码//接口方法
List<User> selectLikeSecond(String username);

xml复制代码<!--mapper文件-->
<select id="selectLikeSecond" resultType="com.domain.User">
select id,username,pwd from user where username like "%" #{studentName} "%"
</select>

xml复制代码<select id="getEmpsByConditionIf" resultType="com.atguigu.mybatis.beans.Employee">
	select id , last_name ,email , gender
	from tbl_employee
		<where>
			<if test="id!=null">
				and id = #{id}
			</if>
			<if test="lastName!=null &amp;&amp; lastName!=&quot;&quot;">
				and last_name = #{lastName}
			</if>
			<if test="email!=null and email.trim()!=''">
				and email = #{email}
			</if>
			<if test="&quot;m&quot;.equals(gender) or &quot;f&quot;.equals(gender)">
				and gender = #{gender}
			</if>
		</where>
</select>

xml复制代码<select id="getEmpsByConditionTrim" resultType="com.atguigu.mybatis.beans.Employee">
    select id , last_name ,email , gender from tbl_employee
	<trim prefix="where" suffixOverrides="and">
		<if test="id!=null">
			id = #{id} and
		</if>
		<if test="lastName!=null &amp;&amp; lastName!=&quot;&quot;">
			last_name = #{lastName} and
		</if>
		<if test="email!=null and email.trim()!=''">
			email = #{email} and
		</if>
		<if test="&quot;m&quot;.equals(gender) or &quot;f&quot;.equals(gender)">
			gender = #{gender}
		</if>
	</trim>
</select>

xml复制代码<update id="updateEmpByConditionSet">
	update tbl_employee
	<set>
		<if test="lastName!=null &amp;&amp; lastName!=&quot;&quot;">
			last_name = #{lastName},
		</if>
		<if test="email!=null and email.trim()!=''">
			email = #{email} ,
		</if>
		<if test="&quot;m&quot;.equals(gender) or &quot;f&quot;.equals(gender)">
			gender = #{gender}
		</if>
	</set>
	where id =#{id}
</update>

xml复制代码<select id="getEmpsByConditionChoose" resultType="com.atguigu.mybatis.beans.Employee">
	select id ,last_name, email,gender from tbl_employee
	<where>
		<choose>
			<when test="id!=null">
				id = #{id}
			</when>
			<when test="lastName!=null">
				last_name = #{lastName}
			</when>
			<when test="email!=null">
				email = #{email}
			</when>
			<otherwise>
				gender = 'm'
			</otherwise>
		</choose>
	</where>
</select>

xml复制代码<select id="getEmpsByConditionForeach" resultType="com.atguigu.mybatis.beans.Employee">
		select id , last_name, email ,gender from tbl_employee where id in
	<foreach collection="ids" item="curr_id" open="(" close=")" separator="," >
		#{curr_id}
	</foreach>
</select>

xml复制代码<sql id="selectSQL">
	select id , last_name, email ,gender from tbl_employee
</sql>

xml复制代码<include refid="selectSQL"></include>

xml复制代码<?xml version="1.0" encoding="UTF-8"?>
<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:noNamespaceSchemaLocation="../config/ehcache.xsd">
<!-- 磁盘保存路径 -->
<diskStore path="D:\atguigu\ehcache" />

<defaultCache
maxElementsInMemory="1000"
maxElementsOnDisk="10000000"
eternal="false"
              overflowToDisk="true"
timeToIdleSeconds="120"
timeToLiveSeconds="120"
diskExpiryThreadIntervalSeconds="120"
memoryStoreEvictionPolicy="LRU">
</defaultCache>
</ehcache>

<!--
属性说明：
l diskStore：指定数据在磁盘中的存储位置。
l defaultCache：当借助CacheManager.add("demoCache")创建Cache时，EhCache
便会采用<defalutCache/>指定的的管理策略

以下属性是必须的：
l maxElementsInMemory - 在内存中缓存的element的最大数目
l maxElementsOnDisk - 在磁盘上缓存的element的最大数目，若是0表示无穷大
l eternal - 设定缓存的elements是否永远不过期。如果为true，则缓存的数据始
终有效，如果为false那么还要根据timeToIdleSeconds，timeToLiveSeconds判断
l overflowToDisk - 设定当内存缓存溢出的时候是否将过期的element缓存到磁
盘上

以下属性是可选的：
l timeToIdleSeconds - 当缓存在EhCache中的数据前后两次访问的时间超过
timeToIdleSeconds的属性取值时，这些数据便会删除，默认值是0,也就是可闲置
时间无穷大
l timeToLiveSeconds - 缓存element的有效生命期，默认是0.,也就是element存活
时间无穷大
diskSpoolBufferSizeMB 这个参数设置DiskStore(磁盘缓存)的缓存区大小.默认
是30MB.每个Cache都应该有自己的一个缓冲区.
l diskPersistent - 在VM重启的时候是否启用磁盘保存EhCache中的数据，默认是
false。
l diskExpiryThreadIntervalSeconds - 磁盘缓存的清理线程运行间隔，默认是120
秒。每个120s，相应的线程会进行一次EhCache中数据的清理工作
l memoryStoreEvictionPolicy - 当内存缓存达到最大，有新的element加入的时
候， 移除缓存中element的策略。默认是LRU（最近最少使用），可选的有LFU
（最不常使用）和FIFO（先进先出）
-->

xml复制代码<cache type="org.mybatis.caches.ehcache.EhcacheCache"></cache>

xml复制代码<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE generatorConfiguration
PUBLIC "-//mybatis.org//DTD MyBatis Generator Configuration 1.0//EN"
"http://mybatis.org/dtd/mybatis-generator-config_1_0.dtd">

<generatorConfiguration>
<!--
targetRuntime: 执行生成的逆向工程的版本
MyBatis3Simple: 生成基本的CRUD
MyBatis3: 生成带条件的CRUD
-->
<context id="DB2Tables" targetRuntime="MyBatis3">
<jdbcConnection driverClass="com.mysql.jdbc.Driver"
connectionURL="jdbc:mysql://localhost:3306/mybatis_1129"
userId="root"
password="1234">
</jdbcConnection>
<!-- javaBean的生成策略-->
<javaModelGenerator targetPackage="com.atguigu.mybatis.beans"
                    targetProject=".\src">
<property name="enableSubPackages" value="true" />
<property name="trimStrings" value="true" />
</javaModelGenerator>
<!-- SQL映射文件的生成策略 -->
<sqlMapGenerator targetPackage="com.atguigu.mybatis.dao"
targetProject=".\conf">
<property name="enableSubPackages" value="true" />
</sqlMapGenerator>

<!-- Mapper接口的生成策略 -->
<javaClientGenerator type="XMLMAPPER"
targetPackage="com.atguigu.mybatis.dao" targetProject=".\src">
<property name="enableSubPackages" value="true" />
</javaClientGenerator>
<!-- 逆向分析的表 -->
<table tableName="tbl_dept" domainObjectName="Department"></table>
<table tableName="tbl_employee" domainObjectName="Employee"></table>
</context>
</generatorConfiguration>

java复制代码    @Test
    public void testMBG() throws Exception {
        List<String> warnings = new ArrayList<String>();
        boolean overwrite = true;
        File configFile = new File("mbg.xml");
        ConfigurationParser cp = new ConfigurationParser(warnings);
        Configuration config = cp.parseConfiguration(configFile);
        DefaultShellCallback callback = new DefaultShellCallback(overwrite);
        MyBatisGenerator myBatisGenerator = new MyBatisGenerator(config,
                callback, warnings);
        myBatisGenerator.generate(null);
    }

java复制代码 @Test
    public void testSelect() throws Exception {
        SqlSessionFactory ssf = getSqlSessionFactory();
        SqlSession session = ssf.openSession();
        try {
            EmployeeMapper mapper =
                    session.getMapper(EmployeeMapper.class);
            List<Employee> emps = mapper.selectAll();
            for (Employee employee : emps) {
                System.out.println(employee);
            }
        } finally {
            session.close();
        }
    }

java复制代码    @Test
    public void testSelect() throws Exception {
        SqlSessionFactory ssf = getSqlSessionFactory();
        SqlSession session = ssf.openSession();
        try {
            EmployeeMapper mapper =
                    session.getMapper(EmployeeMapper.class);
//条件查询: 名字中带有'张' 并且 email中'j' 或者 did = 2
            EmployeeExample example = new EmployeeExample();
            Criteria criteria = example.createCriteria();
            criteria.andLastNameLike("%张%");
            criteria.andEmailLike("%j%");
//or
            Criteria criteriaOr = example.createCriteria();
            criteriaOr.andDIdEqualTo(2);
            example.or(criteriaOr);
            List<Employee> emps = mapper.selectByExample(example);
            for (Employee employee : emps) {
                System.out.println(employee);
            }
        } finally {
            session.close();
        }
    }