dart复制代码static final ThreadLocal<T> sThreadLocal = new ThreadLocal<T>();
sThreadLocal.set()
sThreadLocal.get()

php复制代码/**
 * This class provides thread-local variables.  These variables differ from
 * their normal counterparts in that each thread that accesses one (via its
 * {@code get} or {@code set} method) has its own, independently initialized
 * copy of the variable.  {@code ThreadLocal} instances are typically private
 * static fields in classes that wish to associate state with a thread (e.g.,
 * a user ID or Transaction ID).
 */

scss复制代码//set 方法
public void set(T value) {
      //获取当前线程
      Thread t = Thread.currentThread();
      //实际存储的数据结构类型
      ThreadLocalMap map = getMap(t);
      //如果存在map就直接set，没有则创建map并set
      if (map != null)
          map.set(this, value);
      else
          createMap(t, value);
  }
  
//getMap方法
ThreadLocalMap getMap(Thread t) {
      //thred中维护了一个ThreadLocalMap
      return t.threadLocals;
 }
 
//createMap
void createMap(Thread t, T firstValue) {
      //实例化一个新的ThreadLocalMap，并赋值给线程的成员变量threadLocals
      t.threadLocals = new ThreadLocalMap(this, firstValue);
}

java复制代码/* ThreadLocal values pertaining to this thread. This map is maintained
     * by the ThreadLocal class. */
    ThreadLocal.ThreadLocalMap threadLocals = null;

scala复制代码//Entry为ThreadLocalMap静态内部类，对ThreadLocal的若引用
//同时让ThreadLocal和储值形成key-value的关系
static class Entry extends WeakReference<ThreadLocal<?>> {
    /** The value associated with this ThreadLocal. */
    Object value;

    Entry(ThreadLocal<?> k, Object v) {
           super(k);
            value = v;
    }
}

//ThreadLocalMap构造方法
ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
        //内部成员数组，INITIAL_CAPACITY值为16的常量
        table = new Entry[INITIAL_CAPACITY];
        //位运算，结果与取模相同，计算出需要存放的位置
        //threadLocalHashCode比较有趣
        int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
        table[i] = new Entry(firstKey, firstValue);
        size = 1;
        setThreshold(INITIAL_CAPACITY);
}

ini复制代码//在某一线程声明了ABC三种类型的ThreadLocal
ThreadLocal<A> sThreadLocalA = new ThreadLocal<A>();
ThreadLocal<B> sThreadLocalB = new ThreadLocal<B>();
ThreadLocal<C> sThreadLocalC = new ThreadLocal<C>();

ini复制代码 //ThreadLocalMap中set方法。
  private void set(ThreadLocal<?> key, Object value) {

            // We don't use a fast path as with get() because it is at
            // least as common to use set() to create new entries as
            // it is to replace existing ones, in which case, a fast
            // path would fail more often than not.

            Entry[] tab = table;
            int len = tab.length;
            //获取索引值，这个地方是比较特别的地方
            int i = key.threadLocalHashCode & (len-1);

            //遍历tab如果已经存在则更新值
            for (Entry e = tab[i];
                 e != null;
                 e = tab[i = nextIndex(i, len)]) {
                ThreadLocal<?> k = e.get();

                if (k == key) {
                    e.value = value;
                    return;
                }

                if (k == null) {
                    replaceStaleEntry(key, value, i);
                    return;
                }
            }
            
            //如果上面没有遍历成功则创建新值
            tab[i] = new Entry(key, value);
            int sz = ++size;
            //满足条件数组扩容x2
            if (!cleanSomeSlots(i, sz) && sz >= threshold)
                rehash();
        }

arduino复制代码  //ThreadLocal中threadLocalHashCode相关代码.
    
    private final int threadLocalHashCode = nextHashCode();

    /**
     * The next hash code to be given out. Updated atomically. Starts at
     * zero.
     */
    private static AtomicInteger nextHashCode =
        new AtomicInteger();

    /**
     * The difference between successively generated hash codes - turns
     * implicit sequential thread-local IDs into near-optimally spread
     * multiplicative hash values for power-of-two-sized tables.
     */
    private static final int HASH_INCREMENT = 0x61c88647;

    /**
     * Returns the next hash code.
     */
    private static int nextHashCode() {
        //自增
        return nextHashCode.getAndAdd(HASH_INCREMENT);
    }

java复制代码//ThreadLocal中get方法
public T get() {
    Thread t = Thread.currentThread();
    ThreadLocalMap map = getMap(t);
    if (map != null) {
        ThreadLocalMap.Entry e = map.getEntry(this);
        if (e != null) {
            @SuppressWarnings("unchecked")
            T result = (T)e.value;
            return result;
        }
    }
    return setInitialValue();
}
    
//ThreadLocalMap中getEntry方法
private Entry getEntry(ThreadLocal<?> key) {
       int i = key.threadLocalHashCode & (table.length - 1);
       Entry e = table[i];
       if (e != null && e.get() == key)
            return e;
       else
            return getEntryAfterMiss(key, i, e);
   }

makefile复制代码POST /user HTTP/1.1                       // 请求行
Host: www.user.com
Content-Type: application/x-www-form-urlencoded
Connection: Keep-Alive
User-agent: Mozilla/5.0.                  // 以上是请求头

name=world                                // 请求体(可选,如get请求时可选)

javascript复制代码1 从浏览器中创建 XMLHttpRequests
2 从 node.js 创建 http请求
3 支持 Promise API
4 拦截请求和响应
5 转换请求数据和响应数据
6 取消请求
7 自动转换JSON 数据
8 客户端支持防御XSRF

arduino复制代码//安装
npm install axios --S
//导入
import axios from 'axios'
//封装Axios
//利用node环境变量来作判断，用来区分开发、测试、生产环境
if (process.env.NODE_ENV === 'development') {
  axios.defaults.baseURL = 'http://dev.xxx.com'
} else if (process.env.NODE_ENV === 'production') {
  axios.defaults.baseURL = 'http://prod.xxx.com'
}

ini复制代码/* eslint-disable */
import axios from "axios";
import { baseURL } from "@/config";
import md5 from "js-md5";
// 网络请求记录map结构
let pending = {};
//取消请求
let CancelToken = axios.CancelToken;
class HttpRequest {
    constructor(baseUrl = baseURL) {
        this.baseUrl = baseUrl;
        this.queue = {};
    }
    getInsideConfig(auth) {
        var config = {
            baseURL: this.baseUrl,
            headers: {
                Authorization: auth
            }
        };
        return config;
    }
    distory(url) {
        delete this.queue[url];
        if (!Object.keys(this.queue).length) {
            //Spin.hide()
        }
    }
    interceptors(instance, url) {
        instance.interceptors.request.use(
            config => {
                //检查json数据中是否包含repetitiveRequestLimit属性,若包含,则为此请求添加幂等校验
                if(config.data.hasOwnProperty("repetitiveRequestLimit")){
                    let key = md5(`${config.url}&${config.method}&${JSON.stringify(config.data)}`);
                    config.cancelToken = new CancelToken(c => {
                        if (pending[key]) {
                            if (Date.now() - pending[key] > 5000) {
                                // 超过5s，删除对应的请求记录，重新发起请求
                                delete pending[key];
                            } else {
                                // 5s以内的已发起请求，取消重复请求
                                c("repeated");
                            }
                        }
                    });
                    // 记录当前的请求，已存在则更新时间戳
                    pending[key] = Date.now();
                }else{
                    console.log('我是没有repetitiveRequestLimit的请求')
                }
                return config;
            },
            error => {
                return Promise.reject(error);
            }
        );
        instance.interceptors.response.use(
            res => {
                this.distory(url);
                var { data } = res;
                return data;
            },
            error => {
                // 错误的请求结果处理，这里的代码根据后台的状态码来决定错误的输出信息
                if (error && error.response) {
                    switch (error.response.status) {
                        case 400:
                            error.message = "错误请求";
                            break;
                        case 401:
                            error.message = "未授权，请重新登录";
                            break;
                        case 403:
                            error.message = "拒绝访问";
                            break;
                        case 404:
                            error.message = "请求错误,未找到该资源";
                            break;
                        case 405:
                            error.message = "请求方法未允许";
                            break;
                        case 408:
                            error.message = "请求超时";
                            break;
                        case 500:
                            error.message = "服务器端出错";
                            break;
                        case 501:
                            error.message = "网络未实现";
                            break;
                        case 502:
                            error.message = "网络错误";
                            break;
                        case 503:
                            error.message = "服务不可用";
                            break;
                        case 504:
                            error.message = "网络超时";
                            break;
                        case 505:
                            error.message = "http版本不支持该请求";
                            break;
                        default:
                            error.message = `连接错误${error.response.status}`;
                    }
                } else {
                    error.message = "连接到服务器失败";
                }
                return Promise.reject(error.message);
            }
        );
    }
    request(options) {
        var instance = axios.create();
        options = Object.assign(this.getInsideConfig(localStorage.getItem("Authorization")), options);
        this.interceptors(instance, options.url);
        return instance(options);
    }
}
export default HttpRequest;

arduino复制代码//这里可以根据node环境来设置后台Url
//利用node环境变量来作判断，用来区分开发、测试、生产环境 
/* eslint-disable */
export var baseURL = process.env.NODE_ENV === 'development'?' http://localhost:8080':' http://localhost:8081'

javascript复制代码/* eslint-disable */
import HttpRequest from "@/lib/axios";
var axios = new HttpRequest();
export default axios;

php复制代码/* eslint-disable */
import axios from './baseIndex'
//原生redis实现分布式锁测试
export var getRedisLock = (object) => {
  return axios.request({
    url: "/demo1/testRedisLock",
    method: "post",
    data:object
  });
};
//redisson分布式锁测试
export var getRedissonLock = (object) => {
    return axios.request({
        url: "/demo1/testRedisson",
        method: "post",
        data:object
    });
};

xml复制代码<template>
    <div class="home-container">
        <div class="home-content">
            <Button @click="getUserData">redis分布式锁测试</Button>
            <Button @click="getUserData1">redisson分布式锁测试</Button>
        </div>
    </div>
</template>
<script>
/* eslint-disable */
import {getRedisLock,getRedissonLock} from '@/api/requestdemo1.js'
export default {
    name: 'home',
    data() {
        return {
        }
    },
    methods: {
        getUserData() {
            let person={
                requestName:'请求名称',
                name:'徐超',
                salary:"10000",
                age:23,
                //加上此参数以后,axios会对请求进行幂等操作,即短时间内的重复请求无法发送出去
                repetitiveRequestLimit:true
            }
            getRedisLock(person).then(res=>{
                console.log(res);
            }).catch((e)=>{
                console.log(e);
            }).finally(() => {
                console.log('finish');
            })
        },
        getUserData1(){
            let person={
                requestName:'请求名称',
                name:'徐超',
                salary:"10000",
                age:23,
                orderNumber:"ADW12314123",
                //加上此参数以后,axios会对请求进行幂等操作,即短时间内的重复请求无法发送出去
                //repetitiveRequestLimit:true
            }
            getRedissonLock(person).then(res=>{
                console.log(res);
            }).catch((e)=>{
                console.log(e);
            }).finally(() => {
                console.log('finish');
            })
        }
    },
}
</script>

<style scoped>
.home-container {
    padding: 10px;
    padding-top: 5px;
}
.home-content {
    padding: 10px;
    border-radius: 5px;
    background: #fff;
}
</style>

ini复制代码String uuid = UUID.randomUUID().toString();

ini复制代码String id = Thread.currentThread().getId() + "";

bash复制代码参考:基于Snowflake算法的分布式ID生成器
码云: https://gitee.com/yu120/neural

xml复制代码<!-- jedis-redis -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
            <exclusions>
                <exclusion>
                    <groupId>io.lettuce</groupId>
                    <artifactId>lettuce-core</artifactId>
                </exclusion>
            </exclusions>
        </dependency>

        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
        </dependency>

java复制代码public class RedisLockUtil {

    // key的持有时间，5ms
    private long EXPIRE_TIME = 5;

    // 等待超时时间,1s
    private long TIME_OUT = 1000;

    // redis命令参数，相当于nx和px的命令合集
    private SetParams params = SetParams.setParams().nx().px(EXPIRE_TIME);

    // redis连接池，连的是本地的redis客户端
    JedisPool jedisPool = new JedisPool("127.0.0.1", 6379);

    /**
     * 加锁
     *
     * @param value
     * 线程的id，或者其他可识别当前线程且不重复的字段
     * @return
     */
    public boolean lock(String key,String value) {
        Long start = System.currentTimeMillis();
        Jedis jedis = jedisPool.getResource();
        try {
            for (;;) {
                // SET命令返回OK ，则证明获取锁成功
                String lock = jedis.set(key, value, params);
                if ("OK".equals(lock)) {
                    return true;
                }
                // 否则循环等待，在TIME_OUT时间内仍未获取到锁，则获取失败
                long l = System.currentTimeMillis() - start;
                if (l >= TIME_OUT) {
                    return false;
                }
                try {
                    // 休眠一会，不然反复执行循环会一直失败
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        } finally {
            jedis.close();
        }
    }

    /**
     * 解锁
     *
     * @param value
     * 线程的id，或者其他可识别当前线程且不重复的字段
     * @return
     */
    public boolean unlock(String key,String value) {
        Jedis jedis = jedisPool.getResource();
        // 删除key的lua脚本
        String script = "if redis.call('get',KEYS[1]) == ARGV[1] then" + "   return redis.call('del',KEYS[1]) " + "else"
                + "   return 0 " + "end";
        try {
            String result =
                    jedis.eval(script, Collections.singletonList(key), Collections.singletonList(value)).toString();
            return "1".equals(result);
        } finally {
            jedis.close();
        }
    }
}

typescript复制代码/**
 * @program: structure
 * @description:
 * @author: geekAntony
 * @create: 2021-01-19 22:59
 **/
@RestController
@RequestMapping("/demo1")
public class TestRedisLock {

    private static RedisLockUtil demo = new RedisLockUtil();

     @PostMapping(value = "/testRedisLock")
    public String add(@RequestBody Person person) {
        String id = Thread.currentThread().getId() + "";
        boolean isLock = demo.lock("redislockName",id);
        try {
            //拿到锁的话执行业务操作...
            if (isLock) {
                //模拟3s业务操作
                TimeUnit.SECONDS.sleep(3);
            }else{
                return "请不要重复发送表单请求";
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            // 在finally中释放锁
            demo.unlock("redislockName",id);
        }
        return "完成业务逻辑";
    }
}

xml复制代码 <dependency>
            <groupId>org.redisson</groupId>
            <artifactId>redisson</artifactId>
            <version>3.13.4</version>
        </dependency>

yaml复制代码#Redis 配置
spring:
  redis:
    host: 127.0.0.1
    port: 6379
    database: 1
    password:
    timeout: 10000
    jedis:
      pool:
        max-active: 8
        max-idle: 8
        min-idle: 0
        max-wait: -1ms
#自定义分布式 Redis 客户端 Redisson 配置
redisson:
  type: stand-alone  #redis服务器部署类型，stand-alone:单机部署、cluster：机器部署.默认为单机部署
  address: redis://127.0.0.1:6379 #单机时必须是redis://开头.
  database: 1

arduino复制代码@Data //lombok
@ConfigurationProperties(prefix = "redisson")
public class RedssionProperties {
    
    /**
    * redis服务器部署类型。
    * stand-alone:单机部署
    * cluster：集群部署.
    */
    private String type = "stand-alone";
    /**
    * Redis 服务器地址
    */
    private String address;
    /**
    * 用于Redis连接的数据库索引
    */
    private int database = 0;
    /**
    * Redis身份验证的密码，如果不需要，则应为null
    */
    private String password;
    /**
    * Redis最小空闲连接量
    */
    private int connectionMinimumIdleSize = 24;
    /**
    * Redis连接最大池大小
    */
    private int connectionPoolSize = 64;
    /**
    * Redis 服务器响应超时时间，Redis 命令成功发送后开始倒计时（毫秒）
    */
    private int timeout = 3000;
    /**
    * 连接到 Redis 服务器时超时时间（毫秒）
    */
    private int connectTimeout = 10000;
}

scss复制代码@Configuration
@EnableConfigurationProperties(RedssionProperties.class)
public class RedissonConfig {

    private final RedssionProperties redssionProperties;

    /**
    * 从 Spring 容器中获取 {@link RedssionProperties}实例
    */
    public RedissonConfig(RedssionProperties redssionProperties) {
    	this.redssionProperties = redssionProperties;
    }


    /**
    * redis 服务器单机部署时，创建 RedissonClient 实例，交由 Spring 容器管理
    * 只有当配置了 redisson.type=stand-alone 时，才继续生成 RedissonClient 实例并交由 Spring 容器管理
    *
    * @return
    */
    @Bean
    @ConditionalOnProperty(prefix = "redisson", name = "type", havingValue = "stand-alone")
        public RedissonClient redissonClient() {
        /**
        * Config：Redisson 配置基类：
        * SingleServerConfig：单机部署配置类，MasterSlaveServersConfig：主从复制部署配置
        * SentinelServersConfig：哨兵模式配置，ClusterServersConfig：集群部署配置类。
        * useSingleServer()：初始化 redis 单服务器配置。即 redis 服务器单机部署
        * setAddress(String address)：设置 redis 服务器地址。格式 -- redis://主机:端口，不写时，默认为 redis://127.0.0.1:6379
        * setDatabase(int database): 设置连接的 redis 数据库，默认为 0
        * setPassword(String password)：设置 redis 服务器认证密码，没有时设置为 null，默认为 null
        * RedissonClient create(Config config): 使用提供的配置创建同步/异步 Redisson 实例
        * Redisson 类实现了 RedissonClient 接口，真正需要使用的就是这两个 API
        */
        Config config = new Config();
        config.useSingleServer()
        .setAddress(redssionProperties.getAddress())
        .setDatabase(redssionProperties.getDatabase())
        .setPassword(redssionProperties.getPassword())
        .setConnectionPoolSize(redssionProperties.getConnectionPoolSize())
        .setConnectionMinimumIdleSize(redssionProperties.getConnectionMinimumIdleSize())
        .setTimeout(redssionProperties.getTimeout())
        .setConnectTimeout(redssionProperties.getConnectTimeout());
        RedissonClient redissonClient = Redisson.create(config);
        return redissonClient;
    }
}

xml复制代码<template>
    <div class="home-container">
        <div class="home-content">
            <Button @click="getUserData1">redisson分布式锁测试</Button>
        </div>
    </div>
</template>

<script>
/* eslint-disable */
import {getRedisLock,getRedissonLock} from '@/api/requestdemo1.js'
export default {
    name: 'home',
    data() {
        return {
            userInfo: '',
        }
    },
    methods: {
        getUserData1(){
            let person={
                requestName:'请求名称',
                name:'徐超',
                salary:"10000",
                age:23,
                orderNumber:"ADW12314123",
                //注释掉此字段以免axios拦截器拦截
                //repetitiveRequestLimit:true
            }
            getRedissonLock(person).then(res=>{
                console.log(res);
            }).catch((e)=>{
                console.log(e);
            }).finally(() => {
                console.log('finish');
            })
        }
    },
}
</script>

<style scoped>
.home-container {
    padding: 10px;
    padding-top: 5px;
}
.home-content {
    padding: 10px;
    border-radius: 5px;
    background: #fff;
}
</style>

vbnet复制代码@RestController
@RequestMapping("/demo1")
public class TestRedisLock {

    @Autowired
    private RedissonClient redissonClient;

    private static Logger logger = LoggerFactory.getLogger(TestRedisLock.class);
    /**
    * RedissonClient.getLock(String name)：可重入锁
    * boolean tryLock(long waitTime, long leaseTime, TimeUnit unit)：尝试获取锁
    * 1、waitTime：获取锁时的等待时间，超时自动放弃，线程不再继续阻塞，方法返回 false
    * 2、leaseTime：获取到锁后，指定加锁的时间，超时后自动解锁
    * 3、如果成功获取锁，则返回 true，否则返回 false。
    */
    @PostMapping(value = "/testRedisson")
    public String addDemo1(@RequestBody Person person) {
        String result = "订单[" + person.getOrderNumber() + "]支付成功.";
        //这里可以加入登录用户的id等数据
        String key = person.getOrderNumber();
        /**
        * getLock(String name)：按名称返回锁实例，实现了一个非公平的可重入锁，因此不能保证线程获得顺序
        * lock():获取锁，如果锁不可用，则当前线程将处于休眠状态，直到获得锁为止
        */
        RLock lock = redissonClient.getLock(key);
        boolean tryLock = false;
        try {
            //waitTime是尝试加锁时间,最多等待1s,上锁60s以后自动解锁
            tryLock = lock.tryLock(1, 60, TimeUnit.SECONDS);
        } catch (InterruptedException e) {
        	e.printStackTrace();
        }
        //上锁失败,则会进入此if
        if (!tryLock) {
        	return "订单[" + person.getOrderNumber() + "]正在支付中，请耐心等待！";
        }
        try {
            logger.info("查询支付状态");
            TimeUnit.SECONDS.sleep(1);
            logger.info("正在支付订单[" + person.getOrderNumber() + "]");
            TimeUnit.SECONDS.sleep(1);
         } catch (Exception e) {
            e.printStackTrace();
            result = "订单号xxx [" + person.getOrderNumber() + "]支付失败：" + e.getMessage();
         } finally {
            /**
            * boolean isLocked():检查锁是否被任何线程锁定，被锁定时返回 true，否则返回 false.
            * unlock()：释放锁， Lock 接口的实现类通常会对线程释放锁（通常只有锁的持有者才能释放锁）施加限制，
            * 如果违反了限制，则可能会抛出（未检查的）异常。如果锁已经被释放，重复释放时，会抛出异常。
            */
            if (lock.isLocked()) {
            	lock.unlock();
            }
        }
        return result;
    }
}

python复制代码"""
作者：it项目实例网
网址：www.itprojects.cn
"""

import sys

import pygame

# 要显示的窗口的宽、高
WIDTH, HEIGHT = 750, 667


class ClickBox(pygame.sprite.Sprite):
    """
    选中棋子对象
    """
    singleton = None

    def __new__(cls, *args, **kwargs):
        if cls.singleton is None:
            cls.singleton = super().__new__(cls)
        return cls.singleton

    def __init__(self, screen, row, col, team):
        super().__init__()
        self.image = pygame.image.load("images/r_box.png")
        self.rect = self.image.get_rect()
        self.row, self.col = row, col
        self.rect.topleft = (50 + self.col * 57, 50 + self.row * 57)
        self.screen = screen
        self.team = team

    @classmethod
    def show(cls):
        if cls.singleton:
            cls.singleton.screen.blit(cls.singleton.image, cls.singleton.rect)

    @classmethod
    def clean(cls):
        """
        清理上次的对象
        """
        cls.singleton = None


class Dot(pygame.sprite.Sprite):
    """
    可落棋子类
    """
    group = list()

    def __init__(self, screen, position):
        super().__init__()
        self.image = pygame.image.load("images/dot2.png")
        self.rect = self.image.get_rect()
        self.row, self.col = position  # 将元组拆包
        self.rect.topleft = (60 + self.col * 57, 60 + self.row * 57)
        self.group.append(self)
        self.screen = screen

    @classmethod
    def show(cls):
        for dot in cls.group:
            dot.screen.blit(dot.image, dot.rect)

    @classmethod
    def clean_last_postion(cls):
        """
        清除上次落子位置
        """
        cls.group.clear()

    @classmethod
    def click(cls):
        """
        点击棋子
        """
        for dot in cls.group:
            if pygame.mouse.get_pressed()[0] and dot.rect.collidepoint(pygame.mouse.get_pos()):
                print("被点击了「可落子」对象")
                return dot


class Chess(pygame.sprite.Sprite):
    """
    棋子类
    """

    def __init__(self, screen, chess_name, row, col):
        self.screen = screen
        self.image = pygame.image.load("images/" + chess_name + ".png")
        self.rect = self.image.get_rect()
        self.rect.topleft = (50 + col * 57, 50 + row * 57)
        self.team = chess_name[0]  # 队伍（红方 r、黑方b）
        self.name = chess_name[2]  # 名字（炮p、马m等）
        self.row = row
        self.col = col

    def show(self):
        self.screen.blit(self.image, self.rect)

    @staticmethod
    def click(player, chesses):
        """
        点击棋子
        """
        for chess in chesses:
            if pygame.mouse.get_pressed()[0] and chess.rect.collidepoint(pygame.mouse.get_pos()):
                if player == chess.team:
                    print("被点击了")
                    return chess

    def update_postion(self, new_row, new_col):
        """
        更新要显示的图片的坐标
        """
        self.row = new_row
        self.col = new_col
        self.rect.topleft = (50 + new_col * 57, 50 + new_row * 57)


class ChessBoard(object):
    """
    棋盘类
    """

    def __init__(self, screen):
        self.screen = screen
        self.image = pygame.image.load("images/bg.png")
        self.topleft = (50, 50)
        self.__create_default_chess()

    def __create_default_chess(self):
        """
        创建默认棋子
        """
        self.map = [
            ["b_c", "b_m", "b_x", "b_s", "b_j", "b_s", "b_x", "b_m", "b_c"],
            ["", "", "", "", "", "", "", "", ""],
            ["", "b_p", "", "", "", "", "", "b_p", ""],
            ["b_z", "", "b_z", "", "b_z", "", "b_z", "", "b_z"],
            ["", "", "", "", "", "", "", "", ""],
            ["", "", "", "", "", "", "", "", ""],
            ["r_z", "", "r_z", "", "r_z", "", "r_z", "", "r_z"],
            ["", "r_p", "", "", "", "", "", "r_p", ""],
            ["", "", "", "", "", "", "", "", ""],
            ["r_c", "r_m", "r_x", "r_s", "r_j", "r_s", "r_x", "r_m", "r_c"],
        ]
        for row, line in enumerate(self.map):
            for col, chess_name in enumerate(line):
                if chess_name:
                    # 将创建的棋子添加到属性map中
                    self.map[row][col] = Chess(self.screen, chess_name, row, col)
                else:
                    self.map[row][col] = None

    def show(self):
        # 显示棋盘
        self.screen.blit(self.image, self.topleft)
        # 显示棋盘上的所有棋子
        for line_chess in self.map:
            for chess in line_chess:
                if chess:
                    chess.show()

    def get_put_down_postion(self, clicked_chess):
        """
        计算当前棋子可以移动的位置
        """
        # 存储当前棋子可以落子的位置
        all_position = list()
        # 拿到当前棋子的行、列
        row, col = clicked_chess.row, clicked_chess.col
        # 拿到当前棋子的team，即时红方r还是黑方b
        team = clicked_chess.team

        # 计算当前选中棋子的所有可以落子位置
        if clicked_chess.name == "p":  # 炮
            # 一行
            direction_left_chess_num = 0
            direction_right_chess_num = 0
            for i in range(1, 9):
                # 计算当前行中，棋子左边与右边可以落子的位置
                # 左边位置没有越界
                if direction_left_chess_num >= 0 and col - i >= 0:
                    if not self.map[row][col - i] and direction_left_chess_num == 0:
                        # 如果没有棋子,则将当前位置组成一个元组，添加到列表
                        all_position.append((row, col - i))
                    elif self.map[row][col - i]:
                        # 如果当前位置有棋子，那么就判断是否能够吃掉它
                        direction_left_chess_num += 1
                        if direction_left_chess_num == 2 and self.map[row][col - i].team != team:
                            all_position.append((row, col - i))
                            direction_left_chess_num = -1  # 让其不能够在下次for循环时再次判断
                # 右边位置没有越界
                if direction_right_chess_num >= 0 and col + i <= 8:
                    if not self.map[row][col + i] and direction_right_chess_num == 0:
                        # 如果没有棋子,则将当前位置组成一个元组，添加到列表
                        all_position.append((row, col + i))
                    elif self.map[row][col + i]:
                        # 如果当前位置有棋子，那么就判断是否能够吃掉它
                        direction_right_chess_num += 1
                        if direction_right_chess_num == 2 and self.map[row][col + i].team != team:
                            all_position.append((row, col + i))
                            direction_right_chess_num = -1
            # 一列
            direction_up_chess_num = 0
            direction_down_chess_num = 0
            for i in range(1, 10):  # 这样就让i从1开始，而不是从0
                # 计算当前列中，棋子上边与下边可以落子的位置
                # 上边位置没有越界
                if direction_up_chess_num >= 0 and row - i >= 0:
                    if not self.map[row - i][col] and direction_up_chess_num == 0:
                        # 如果没有棋子,则将当前位置组成一个元组，添加到列表
                        all_position.append((row - i, col))
                    elif self.map[row - i][col]:
                        # 如果当前位置有棋子，那么就判断是否能够吃掉它
                        direction_up_chess_num += 1
                        if direction_up_chess_num == 2 and self.map[row - i][col].team != team:
                            all_position.append((row - i, col))
                            direction_up_chess_num = -1

                # 下边位置没有越界
                if direction_down_chess_num >= 0 and row + i <= 9:
                    if not self.map[row + i][col] and direction_down_chess_num == 0:
                        # 如果没有棋子,则将当前位置组成一个元组，添加到列表
                        all_position.append((row + i, col))
                    elif self.map[row + i][col]:
                        # 如果当前位置有棋子，那么就判断是否能够吃掉它
                        direction_down_chess_num += 1
                        if direction_down_chess_num == 2 and self.map[row + i][col].team != team:
                            all_position.append((row + i, col))
                            direction_down_chess_num = -1
        elif clicked_chess.name == "z":  # 卒
            if team == "r":  # 红方
                if row - 1 >= 0:  # 只能向上移动
                    if not self.map[row - 1][col] or self.map[row - 1][col].team != team:
                        all_position.append((row - 1, col))
            else:  # 黑方
                if row + 1 <= 9:  # 只能向下移动
                    if not self.map[row + 1][col] or self.map[row + 1][col].team != team:
                        all_position.append((row + 1, col))
            # 左右判断
            if (team == "r" and 0 <= row <= 4) or (team == "b" and 5 <= row <= 9):  # 左、右一步
                # 左
                if col - 1 >= 0 and (not self.map[row][col - 1] or self.map[row][col - 1].team != team):
                    all_position.append((row, col - 1))
                # 右
                if col + 1 <= 8 and (not self.map[row][col + 1] or self.map[row][col + 1].team != team):
                    all_position.append((row, col + 1))
        elif clicked_chess.name == "c":  # 车
            # 一行
            left_stop = False
            right_stop = False
            for i in range(1, 9):
                # 左边位置没有越界且没有遇到任何一个棋子
                if not left_stop and col - i >= 0:
                    if not self.map[row][col - i]:
                        # 如果没有棋子,则将当前位置组成一个元组，添加到列表
                        all_position.append((row, col - i))
                    else:
                        left_stop = True
                        if self.map[row][col - i].team != team:
                            # 如果当前位置有棋子，那么就判断是否能够吃掉它
                            all_position.append((row, col - i))
                # 右边位置没有越界且没有遇到任何一个棋子
                if not right_stop and col + i <= 8:
                    if not self.map[row][col + i]:
                        # 如果没有棋子,则将当前位置组成一个元组，添加到列表
                        all_position.append((row, col + i))
                    else:
                        right_stop = True
                        if self.map[row][col + i].team != team:
                            # 如果当前位置有棋子，那么就判断是否能够吃掉它
                            all_position.append((row, col + i))

            # 一列
            up_stop = False
            down_stoop = False
            for i in range(1, 10):
                # 上边位置没有越界且没有遇到任何一个棋子
                if not up_stop and row - i >= 0:
                    if not self.map[row - i][col]:
                        # 如果没有棋子,则将当前位置组成一个元组，添加到列表
                        all_position.append((row - i, col))
                    else:
                        up_stop = True
                        if self.map[row - i][col].team != team:
                            # 如果当前位置有棋子，那么就判断是否能够吃掉它
                            all_position.append((row - i, col))
                # 下边位置没有越界且没有遇到任何一个棋子
                if not down_stoop and row + i <= 9:
                    if not self.map[row + i][col]:
                        # 如果没有棋子,则将当前位置组成一个元组，添加到列表
                        all_position.append((row + i, col))
                    else:
                        down_stoop = True
                        if self.map[row + i][col].team != team:
                            # 如果当前位置有棋子，那么就判断是否能够吃掉它
                            all_position.append((row + i, col))
        elif clicked_chess.name == "m":  # 马
            # 需要判断的是4个方向，每个方向对应2个位置
            # 上方
            if row - 1 >= 0 and not self.map[row - 1][col]:  # 如果当前棋子没有被蹩马腿，那么再对这个方向的2个位置进行判断
                # 左上
                if row - 2 >= 0 and col - 1 >= 0 and (not self.map[row - 2][col - 1] or self.map[row - 2][col - 1].team != team):
                    all_position.append((row - 2, col - 1))
                # 右上
                if row - 2 >= 0 and col + 1 <= 8 and (not self.map[row - 2][col + 1] or self.map[row - 2][col + 1].team != team):
                    all_position.append((row - 2, col + 1))
            # 下方
            if row + 1 <= 9 and not self.map[row + 1][col]:  # 如果当前棋子没有被蹩马腿，那么再对这个方向的2个位置进行判断
                # 左下
                if row + 2 >= 0 and col - 1 >= 0 and (not self.map[row + 2][col - 1] or self.map[row + 2][col - 1].team != team):
                    all_position.append((row + 2, col - 1))
                # 右下
                if row + 2 >= 0 and col + 1 <= 8 and (not self.map[row + 2][col + 1] or self.map[row + 2][col + 1].team != team):
                    all_position.append((row + 2, col + 1))
            # 左方
            if col - 1 >= 0 and not self.map[row][col - 1]:  # 如果当前棋子没有被蹩马腿，那么再对这个方向的2个位置进行判断
                # 左上2（因为有左上了，暂且称为左上2吧）
                if row - 1 >= 0 and col - 2 >= 0 and (not self.map[row - 1][col - 2] or self.map[row - 1][col - 2].team != team):
                    all_position.append((row - 1, col - 2))
                # 左下2
                if row + 1 <= 9 and col - 2 >= 0 and (not self.map[row + 1][col - 2] or self.map[row + 1][col - 2].team != team):
                    all_position.append((row + 1, col - 2))
            # 右方
            if col + 1 <= 8 and not self.map[row][col + 1]:  # 如果当前棋子没有被蹩马腿，那么再对这个方向的2个位置进行判断
                # 右上2（因为有右上了，暂且称为右上2吧）
                if row - 1 >= 0 and col + 2 <= 8 and (not self.map[row - 1][col + 2] or self.map[row - 1][col + 2].team != team):
                    all_position.append((row - 1, col + 2))
                # 右下2
                if row + 1 <= 9 and col + 2 <= 8 and (not self.map[row + 1][col + 2] or self.map[row + 1][col + 2].team != team):
                    all_position.append((row + 1, col + 2))
        elif clicked_chess.name == "x":  # 象
            # 因为象是不能过河的，所以要计算出它们可以移动的行的范围
            row_start, row_stop = (0, 4) if team == "b" else (5, 9)
            # 有4个方向的判断(没有越界，且没有蹩象腿)
            if row - 2 >= row_start and col - 2 >= 0 and not self.map[row - 1][col - 1]:  # 左上
                if not self.map[row - 2][col - 2] or self.map[row - 2][col - 2].team != team:
                    all_position.append((row - 2, col - 2))
            if row - 2 >= row_start and col + 2 <= 8 and not self.map[row - 1][col + 1]:  # 右上
                if not self.map[row - 2][col + 2] or self.map[row - 2][col + 2].team != team:
                    all_position.append((row - 2, col + 2))
            if row + 2 <= row_stop and col - 2 >= 0 and not self.map[row + 1][col - 1]:  # 左下
                if not self.map[row + 2][col - 2] or self.map[row + 2][col - 2].team != team:
                    all_position.append((row + 2, col - 2))
            if row + 2 <= row_stop and col + 2 <= 8 and not self.map[row + 1][col + 1]:  # 右下
                if not self.map[row + 2][col + 2] or self.map[row + 2][col + 2].team != team:
                    all_position.append((row + 2, col + 2))
        elif clicked_chess.name == "s":  # 士
            # 因为士是不能过河的，所以要计算出它们可以移动的行的范围
            row_start, row_stop = (0, 2) if team == "b" else (7, 9)
            if row - 1 >= row_start and col - 1 >= 3 and (not self.map[row - 1][col - 1] or self.map[row - 1][col - 1].team != team):
                all_position.append((row - 1, col - 1))
            if row - 1 >= row_start and col + 1 <= 5 and (not self.map[row - 1][col + 1] or self.map[row - 1][col + 1].team != team):
                all_position.append((row - 1, col + 1))
            if row + 1 <= row_stop and col - 1 >= 3 and (not self.map[row + 1][col - 1] or self.map[row + 1][col - 1].team != team):
                all_position.append((row + 1, col - 1))
            if row + 1 <= row_stop and col + 1 <= 5 and (not self.map[row + 1][col + 1] or self.map[row + 1][col + 1].team != team):
                all_position.append((row + 1, col + 1))
        elif clicked_chess.name == "j":  # 将
            # 因为"将"是不能过河的，所以要计算出它们可以移动的行的范围
            row_start, row_stop = (0, 2) if team == "b" else (7, 9)
            # 有4个方向的判断
            if row - 1 >= row_start and (not self.map[row - 1][col] or self.map[row - 1][col].team != team):
                all_position.append((row - 1, col))
            if row + 1 <= row_stop and (not self.map[row + 1][col] or self.map[row + 1][col].team != team):
                all_position.append((row + 1, col))
            if col - 1 >= 3 and (not self.map[row][col - 1] or self.map[row][col - 1].team != team):
                all_position.append((row, col - 1))
            if col + 1 <= 5 and (not self.map[row][col + 1] or self.map[row][col + 1].team != team):
                all_position.append((row, col + 1))

        all_position = self.judge_delete_position(all_position, clicked_chess)

        # 返回可以落子的所有位置
        return all_position

    def judge_delete_position(self, all_position, clicked_chess):
        """
        删除被"将军"的位置
        """
        # 定义要删除的列表
        deleting_position = list()

        # 判断这些位置，是否会导致被"将军"，如果是则从列表中删除这个位置
        for row, col in all_position:
            # 1. 备份
            # 备份当前棋子位置
            old_row, old_col = clicked_chess.row, clicked_chess.col
            # 备份要落子的位置的棋子(如果没有，则为None)
            position_chess_backup = self.map[row][col]
            # 2. 挪动位置
            # 移动位置
            self.map[row][col] = self.map[old_row][old_col]
            # 修改棋子的属性
            self.map[row][col].update_postion(row, col)
            # 清楚之前位置为None
            self.map[old_row][old_col] = None
            # 3. 判断对方是否可以发起"将军"
            if self.judge_attack_general("b" if clicked_chess.team == "r" else "r"):
                deleting_position.append((row, col))
            # 4. 恢复到之前位置
            self.map[old_row][old_col] = self.map[row][col]
            self.map[old_row][old_col].update_postion(old_row, old_col)
            self.map[row][col] = position_chess_backup

        # 5. 删除不能落子的位置
        all_position = list(set(all_position) - set(deleting_position))

        return all_position

    def move_chess(self, new_row, new_col):
        """
        落子
        """
        # 得到要移动的棋子的位置
        old_row, old_col = ClickBox.singleton.row, ClickBox.singleton.col
        print("旧位置：", old_row, old_col, "新位置：", new_row, new_col)
        # 移动位置
        self.map[new_row][new_col] = self.map[old_row][old_col]
        # 修改棋子的属性
        self.map[new_row][new_col].update_postion(new_row, new_col)
        # 清楚之前位置为None
        self.map[old_row][old_col] = None

    def judge_attack_general(self, attact_player):
        """
        判断 attact_player方是否 将对方的军
        """
        # 1. 找到对方"将"的位置
        general_player = "r" if attact_player == "b" else "b"
        general_position = self.get_general_position(general_player)

        # 2. 遍历我方所有的棋子
        for row, line in enumerate(self.map):
            for col, chess in enumerate(line):
                if chess and chess.team == attact_player:
                    if chess.name == "z":  # 兵
                        # 传递5个参数（攻击方的标识，攻击方row，攻击方col，对方将row，对方将col）
                        if self.judge_z_attack(chess.team, chess.row, chess.col, *general_position):
                            return True
                    elif chess.name == "p":  # 炮
                        if self.judge_c_and_p_attack(chess.name, chess.row, chess.col, *general_position):
                            return True
                    elif chess.name == "c":  # 车
                        if self.judge_c_and_p_attack(chess.name, chess.row, chess.col, *general_position):
                            return True
                    elif chess.name == "m":  # 马
                        if self.judge_m_attack(chess.row, chess.col, *general_position):
                            return True
                    elif chess.name == "x":  # 象
                        pass
                    elif chess.name == "s":  # 士
                        pass
                    elif chess.name == "j":  # 将
                        if self.judge_j_attack(chess.row, chess.col, *general_position):
                            return True

    def judge_j_attack(self, attack_row, attack_col, general_row, general_col):
        """
        判断 两个将是否相对
        """
        if attack_col == general_col:
            # 在同一列
            min_row, max_row = (attack_row, general_row) if attack_row < general_row else (general_row, attack_row)

            chess_num = 0
            for i in range(min_row + 1, max_row):
                if self.map[i][general_col]:
                    chess_num += 1
            if chess_num == 0:
                return True

    def judge_m_attack(self, attack_row, attack_col, general_row, general_col):
        """
        判断马是否攻击到"将"
        """
        if attack_row == general_row or attack_col == general_col:
            return False
        else:
            # "马走日"，利用这个特点会得出，如果此马能够攻击到"将"，那么两条边的平方和一定是5
            col_length = (attack_col - general_col) ** 2
            row_length = (attack_row - general_row) ** 2
            if col_length + row_length == 5:
                # 判断是否蹩马腿
                if col_length == 1:
                    if general_row < attack_row and not self.map[attack_row - 1][attack_col]:
                        return True
                    elif general_row > attack_row and not self.map[attack_row + 1][attack_col]:
                        return True
                elif col_length == 4:
                    if general_col < attack_col and not self.map[attack_row][attack_col - 1]:
                        return True
                    elif general_col > attack_col and not self.map[attack_row][attack_col + 1]:
                        return True

    def judge_c_and_p_attack(self, attack_chess_name, attack_row, attack_col, general_row, general_col):
        """
        判断"车"、"炮"能否攻击到对方"将"
        """
        check_chess_num = 1 if attack_chess_name == "p" else 0
        chess_num = 0
        if attack_row == general_row:
            # 在同一行
            min_col, max_col = (attack_col, general_col) if attack_col < general_col else (general_col, attack_col)
            for i in range(min_col + 1, max_col):
                if self.map[attack_row][i]:
                    chess_num += 1
            if chess_num == check_chess_num:
                return True
        elif attack_col == general_col:
            # 在同一列
            min_row, max_row = (attack_row, general_row) if attack_row < general_row else (general_row, attack_row)
            for i in range(min_row + 1, max_row):
                if self.map[i][general_col]:
                    chess_num += 1
            if chess_num == check_chess_num:
                return True

    def judge_z_attack(self, attack_team, attack_row, attack_col, general_row, general_col):
        """
        判断卒是否攻击到"将"
        """
        if attack_team == "r" and attack_row < general_row:
            return False
        elif attack_team == "b" and attack_row > general_row:
            return False
        elif (attack_row - general_row) ** 2 + (attack_col - general_col) ** 2 == 1:
            return True

    def get_general_position(self, general_player):
        """
        找到general_player标记的一方的将的位置
        """
        for row, line in enumerate(self.map):
            for col, chess in enumerate(line):
                if chess and chess.team == general_player and chess.name == "j":
                    return chess.row, chess.col

    def judge_win(self, attack_player):
        """
        判断是否获胜
        """
        # 依次判断是否被攻击方的所有棋子，是否有阻挡攻击的可能
        for line_chesses in self.map:
            for chess in line_chesses:
                if chess and chess.team != attack_player:
                    move_position_list = self.get_put_down_postion(chess)
                    if move_position_list:  # 只要找到一个可以移动的位置，就表示没有失败，还是有机会的
                        return False

        return True


class Game(object):
    """
    游戏类
    """

    def __init__(self, screen):
        self.screen = screen
        self.player = "r"  # 默认走棋的为红方r
        self.player_tips_r_image = pygame.image.load("images/red.png")
        self.player_tips_r_image_topleft = (550, 500)
        self.player_tips_b_image = pygame.image.load("images/black.png")
        self.player_tips_b_image_topleft = (550, 100)
        self.show_attack = False
        self.show_attack_count = 0
        self.show_attack_time = 100
        self.attack_img = pygame.image.load("images/pk.png")
        self.show_win = False
        self.win_img = pygame.image.load("images/win.png")
        self.win_player = None

    def get_player(self):
        """
        获取当前走棋方
        """
        return self.player

    def exchange(self):
        """
        交换走棋方
        """
        self.player = "r" if self.player == "b" else "b"
        return self.get_player()

    def show(self):
        if self.show_win:
            if self.win_player == "b":
                self.screen.blit(self.win_img, (550, 100))
            else:
                self.screen.blit(self.win_img, (550, 450))
            return

        # 通过计时，实现显示一会"将军"之后，就消失
        if self.show_attack:
            self.show_attack_count += 1
            if self.show_attack_count == self.show_attack_time:
                self.show_attack_count = 0
                self.show_attack = False

        if self.player == "r":
            self.screen.blit(self.player_tips_r_image, self.player_tips_r_image_topleft)
            # 显示"将军"效果
            if self.show_attack:
                self.screen.blit(self.attack_img, (230, 400))
        else:
            self.screen.blit(self.player_tips_b_image, self.player_tips_b_image_topleft)
            # 显示"将军"效果
            if self.show_attack:
                self.screen.blit(self.attack_img, (230, 100))

    def set_attack(self):
        """
        标记"将军"效果
        """
        self.show_attack = True

    def set_win(self, win_player):
        """
        设置获胜方
        """
        self.show_win = True
        self.win_player = win_player


def main():
    # 初始化pygame
    pygame.init()
    # 创建用来显示画面的对象（理解为相框）
    screen = pygame.display.set_mode((WIDTH, HEIGHT))
    # 游戏背景图片
    background_img = pygame.image.load("images/bg.jpg")
    # 创建游戏对象
    game = Game(screen)
    # 创建一个游戏棋盘对象
    chess_board = ChessBoard(screen)
    # 创建计时器
    clock = pygame.time.Clock()

    # 主循环
    while True:
        # 事件检测（例如点击了键盘、鼠标等）
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                pygame.quit()
                sys.exit()  # 退出程序

            # 如果游戏没有获胜方，则游戏继续，否则一直显示"获胜"
            if not game.show_win:
                # 检测是否点击了"可落子"对象
                clicked_dot = Dot.click()
                if clicked_dot:
                    chess_board.move_chess(clicked_dot.row, clicked_dot.col)
                    # 清理「点击对象」、「可落子位置对象」
                    Dot.clean_last_postion()
                    ClickBox.clean()
                    # 判断此棋子走完之后，是否"将军"
                    if chess_board.judge_attack_general(game.get_player()):
                        # 检测对方是否可以挽救棋局，如果能挽救，就显示"将军"，否则显示"胜利"
                        if chess_board.judge_win(game.get_player()):
                            game.set_win(game.get_player())
                        else:
                            # 如果攻击到对方，则标记显示"将军"效果
                            game.set_attack()
                    # 落子之后，交换走棋方
                    game.exchange()
                # 检查是否点击了棋子
                clicked_chess = Chess.click(game.get_player(), [chess for line in chess_board.map for chess in line if chess])
                if clicked_chess:
                    # 创建选中棋子对象
                    ClickBox(screen, clicked_chess.row, clicked_chess.col, clicked_chess.team)
                    # 清除之前的所有的可以落子对象
                    Dot.clean_last_postion()
                    # 真的点击了棋子，那么计算当前被点击的棋子可以走的位置
                    all_position = chess_board.get_put_down_postion(clicked_chess)
                    if all_position:
                        # 清空上次可落子对象
                        Dot.clean_last_postion()
                        # 创建可落子对象
                        for position in all_position:
                            Dot(screen, position)

        # 显示游戏背景
        screen.blit(background_img, (0, 0))
        screen.blit(background_img, (0, 270))
        screen.blit(background_img, (0, 540))

        # 显示棋盘以及棋盘上的棋子
        chess_board.show()

        # 显示被点击的棋子
        ClickBox.show()

        # 显示可落子对象
        Dot.show()

        # 显示游戏相关信息
        game.show()

        # 显示screen这个相框的内容（此时在这个相框中的内容像照片、文字等会显示出来）
        pygame.display.update()

        # FPS（每秒钟显示画面的次数）
        clock.tick(60)  # 通过一定的延时，实现1秒钟能够循环60次


if __name__ == '__main__':
    main()

java复制代码<!-- https://mvnrepository.com/artifact/org.mybatis.generator/mybatis-generator-core -->
<dependency>
    <groupId>org.mybatis.generator</groupId>
    <artifactId>mybatis-generator-core</artifactId>
    <version>1.3.5</version>
</dependency>

java复制代码<?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>
	<!--这里用的是MyBatis3Simple即简单的增删改查-->
	<!--一般使用MyBatis3-->
  <context id="DB2Tables" targetRuntime="MyBatis3Simple">
    
    <!-- 逆向生成清除注释 -->
    <commentGenerator>
    <property name="suppressAllComments" value="true" />
	</commentGenerator>

      <!-- 数据库连接配置 -->
    <jdbcConnection 
    	driverClass="com.mysql.cj.jdbc.Driver"
        connectionURL="jdbc:mysql://localhost:3306/experiment9?serverTimezone=UTC"
        userId="root"
        password="数据库密码">
        <property name="nullCatalogMeansCurrent" value="true"/>
    </jdbcConnection>

    <javaTypeResolver >
      <property name="forceBigDecimals" value="false" />
    </javaTypeResolver>

	<!-- 指定javaBean逆生成位置 -->
    <javaModelGenerator 
    	targetPackage="cn.csdn.bean" 
    	targetProject=".\src\main\java">
      <property name="enableSubPackages" value="true" />
      <property name="trimStrings" value="true" />
    </javaModelGenerator>
	
	<!-- 指定sql映射文件生成的位置 -->
    <sqlMapGenerator 
    targetPackage="mapper"  
    targetProject=".\src\main\resources">
      <property name="enableSubPackages" value="true" />
    </sqlMapGenerator>
	
	<!-- 指定dao接口生成的位置，mapper接口 -->
    <javaClientGenerator 
    type="XMLMAPPER" 
    targetPackage="cn.csdn.dao"  
    targetProject=".\src\main\java">
      <property name="enableSubPackages" value="true" />
    </javaClientGenerator>
	
	<!-- 指定每个表的生成策略 -->
    <table tableName="message" domainObjectName="Message"></table>
    <table tableName="product" domainObjectName="Product"></table>
    <table tableName="revert" domainObjectName="Revert"></table>
    <table tableName="user" domainObjectName="User"></table>

  </context>
</generatorConfiguration>

java复制代码package cn.csdn.test;

import java.io.File;
import java.util.ArrayList;
import java.util.List;

import org.mybatis.generator.api.MyBatisGenerator;
import org.mybatis.generator.config.Configuration;
import org.mybatis.generator.config.xml.ConfigurationParser;
import org.mybatis.generator.internal.DefaultShellCallback;

public class MBGTest {
	public static void main(String[] args) 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);
		   System.out.println("finish");
	}
}

javascript复制代码<script src="https://smtpjs.com/v3/smtp.js">
</script>

java复制代码<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>发送邮件测试</title>
 <%
        pageContext.setAttribute("APP_PATH",request.getContextPath());
%>
<script type="text/javascript" src="${APP_PATH}/static/js/smtp.js"></script>
</head>
<body>
<script type="text/javascript">
Email.send({
    Host : "smtp.yourisp.com",
    Username : "username",
    Password : "password",
    To : 'them@website.com',
    From : "you@isp.com",
    Subject : "This is the subject",
    Body : "And this is the body"
}).then(
  message => alert(message)
);
</script>
</body>
</html>

javascript复制代码Email.send({
    SecureToken : "密钥",
    To : 'them@website.com',
    From : "you@isp.com",
    Subject : "This is the subject",
    Body : "And this is the body"
}).then(
  message => alert(message)
);

javascript复制代码Email.send({
    SecureToken : "密钥",
    To : 'them@website.com',
    From : "you@isp.com",
    Subject : "This is the subject",
    Body : "And this is the body",
	Attachments : [
	{
		name : "smtpjs.png",
		path : "https://networkprogramming.files.wordpress.com/2017/11/smtpjs.png"
	}]
}).then(
  message => alert(message)
);

java复制代码<dependency>
	<groupId>com.aliyun</groupId>
    <artifactId>aliyun-java-sdk-core</artifactId>
    <version>4.5.1</version>
</dependency>
<dependency>
	<groupId>com.aliyun</groupId>
    <artifactId>aliyun-java-sdk-dysmsapi</artifactId>
    <version>1.1.0</version>
</dependency>