Canal MySQL日志同步Redis （JAVA代码实现）-----下

在上一个博客安装成功了（Canal确认启动成功），然后接下来进行代码实现了。
https://blog.youkuaiyun.com/d875708765/article/details/106430762

同步需要一直运行着，所以这个创建一个普通的Maven工程，然后打成jar包放到服务器进行运行（最好现在本地测试了没有问题在放上去）

以下是依赖
    <dependencies>
        <!--阿里巴巴canal-->
        <dependency>
            <groupId>com.alibaba.otter</groupId>
            <artifactId>canal.client</artifactId>
            <version>1.1.0</version>
        </dependency>
        <!--jedis-->
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>3.3.0</version>
        </dependency>
    </dependencies>

版本可以在maven仓库进行查看

https://mvnrepository.com/search?q=canal

如果出现canal版本不支持建议降版本

RedisUtil工具类
可以根据自己的需求去自行增加一些方法

import redis.clients.jedis.Jedis;

/**
 * @author D
 */
public class RedisUtil {
    private static Jedis jedis = null;

    public static synchronized Jedis getJedis(){
    //端口默认是6379 看自己修改的
        if (jedis == null) {
            jedis = new Jedis("服务器Ip", "端口");
            jedis.auth("密码");
        }
        return jedis;
    }

    public static boolean existKey(String key) {
        return getJedis().exists(key);
    }

    public static void delKey(String key) {
        getJedis().del(key);
    }

    public static String stringGet(String key) {
        return getJedis().get(key);
    }

    public static String stringSet(String key, String value) {
        return getJedis().set(key, value);
    }

    public static void hashSet(String key, String field, String value) {
        getJedis().hset(key, field, value);
    }
    public static void hashDel(String key, String field) {
        getJedis().hdel(key,field);
    }
    public static Long incr(String key, long value){
        return getJedis().incrBy(key, value);
    }
    public static Double incrByFloat(String key, double value){
        return getJedis().incrByFloat(key, value);
    }
}

CanalClient类含主函数

import com.alibaba.fastjson.JSONObject;
import com.alibaba.otter.canal.client.CanalConnector;
import com.alibaba.otter.canal.client.CanalConnectors;
import com.alibaba.otter.canal.protocol.CanalEntry;
import com.alibaba.otter.canal.protocol.Message;

import java.math.BigDecimal;
import java.math.BigInteger;
import java.net.InetSocketAddress;
import java.sql.Timestamp;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.List;

/**
 * 阿里巴巴Canal
 * @author D
 */
public class CanalClient {

    public static void main(String[] args) {
        CanalConnector connector = CanalConnectors.newSingleConnector(new InetSocketAddress("服务器IP",
                11111),"example","root","123456");
        int batchSize = 100;
        System.out.println(connector+"测试");
        try {
            connector.connect();
            connector.subscribe(".*\\..*");
            connector.rollback();
            while (true) {
                // 获取指定数量的数据
                Message message = connector.getWithoutAck(batchSize);
                long batchId = message.getId();
                int size = message.getEntries().size();
                System.out.println("batchId = " + batchId);
                System.out.println("size = " + size);
                if (batchId == -1 || size == 0) {
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                } else {
                    printEntry(message.getEntries());
                }
                // 提交确认
                connector.ack(batchId);
                // connector.rollback(batchId); // 处理失败, 回滚数据
            }
        } finally {
            connector.disconnect();
        }
    }

    private static void printEntry(List<CanalEntry.Entry> entrys) {
        for (CanalEntry.Entry entry : entrys) {

            if (entry.getEntryType() == CanalEntry.EntryType.TRANSACTIONBEGIN || entry.getEntryType() == CanalEntry.EntryType.TRANSACTIONEND) {
                continue;
            }
            CanalEntry.RowChange rowChage = null;
            try {
                rowChage = CanalEntry.RowChange.parseFrom(entry.getStoreValue());
            } catch (Exception e) {
                throw new RuntimeException("ERROR ## parser of eromanga-event has an error , data:" + entry.toString(),
                        e);
            }
            CanalEntry.EventType eventType = rowChage.getEventType();
            System.out.println(String.format("================> binlog[%s:%s] , name[%s,%s] , eventType : %s",
                    entry.getHeader().getLogfileName(), entry.getHeader().getLogfileOffset(),
                    entry.getHeader().getSchemaName(), entry.getHeader().getTableName(),
                    eventType));
            System.out.println(entry);
            for (CanalEntry.RowData rowData : rowChage.getRowDatasList()) {
                System.out.println(rowData);
                if (eventType == CanalEntry.EventType.DELETE) {
                    redisDelete(rowData.getBeforeColumnsList(),entry.getHeader().getTableName());
                } else if (eventType == CanalEntry.EventType.INSERT) {
                    redisInsert(rowData.getAfterColumnsList(),entry.getHeader().getTableName());
                } else {
                    System.out.println("-------> before");
                    printColumn(rowData.getBeforeColumnsList());
                    System.out.println("-------> after");
                    redisUpdate(rowData.getAfterColumnsList(),entry.getHeader().getTableName());
                }
            }
        }
    }

    private static void printColumn(List<CanalEntry.Column> columns) {
        for (CanalEntry.Column column : columns) {
            System.out.println(column.getName() + " : " + column.getValue() + "    update=" + column.getUpdated());
        }
    }

    private static void redisInsert(List<CanalEntry.Column> columns,String tableName) {

        JSONObject json = new JSONObject(true);
        //将第一个字母大写 应该对应自己的实体类 比如 数据库 user 实体类 User 数据库名建议使用驼峰命名  实体类第一个字母大写同样驼峰
        // com.zsc.newbuds.entity  这个根据自己实体类的包名进行更改
        json.put("@class","com.zsc.newbuds.entity."+tableName.substring(0, 1).toUpperCase()+tableName.substring(1));
        for (CanalEntry.Column column : columns) {
            //类型转换
            String name = CanalClient.convertToString(column.getName());
            Object value = CanalClient.convertType(column.getMysqlType(),column.getValue());
            json.put(name, value);
        }
        if (columns.size() > 0) {
            //进行redis操作
            RedisUtil.stringSet(tableName+":"  + CanalClient.convertToString(columns.get(0).getValue()), json.toJSONString());
        }
    }

    private static void redisUpdate(List<CanalEntry.Column> columns,String tableName) {
        JSONObject json = new JSONObject(true);
        //将第一个字母大写 应该对应自己的实体类 比如 数据库 user 实体类 User 数据库名建议使用驼峰命名  实体类第一个字母大写同样驼峰
        // com.zsc.newbuds.entity  这个根据自己实体类的包名进行更改
        json.put("@class","com.zsc.newbuds.entity."+tableName.substring(0, 1).toUpperCase()+tableName.substring(1));
        for (CanalEntry.Column column : columns) {
            //类型转换
            String name = CanalClient.convertToString(column.getName());
            Object value = CanalClient.convertType(column.getMysqlType(),column.getValue());
            json.put(name, value);
        }
        if (columns.size() > 0) {
            //进行redis操作
            RedisUtil.stringSet(tableName+":"  + CanalClient.convertToString(columns.get(0).getValue()), json.toJSONString());
        }
    }

    private static void redisDelete(List<CanalEntry.Column> columns,String tableName) {

        JSONObject json = new JSONObject(true);
        //将第一个字母大写 应该对应自己的实体类 比如 数据库 user 实体类 User 数据库名建议使用驼峰命名  实体类第一个字母大写同样驼峰
        // com.zsc.newbuds.entity  这个根据自己实体类的包名进行更改
        json.put("@class","com.zsc.newbuds.entity."+tableName.substring(0, 1).toUpperCase()+tableName.substring(1));
        for (CanalEntry.Column column : columns) {
            //类型转换
            String name = CanalClient.convertToString(column.getName());
            Object value = CanalClient.convertType(column.getMysqlType(),column.getValue());
            json.put(name, value);
        }
        if (columns.size() > 0) {
            //进行redis操作
            RedisUtil.delKey(tableName+":"  + CanalClient.convertToString(columns.get(0).getValue()));
        }


    }

    /**
     * 将 user_name 转为驼峰命名userName
     * @param srcStr user_name
     * @return 驼峰命名userName
     */
    private static String convertToString(String srcStr){
        StringBuilder newString = new StringBuilder();
        int first = 0;
        while (srcStr.contains("_")) {
            first = srcStr.indexOf("_");
            if (first != srcStr.length()) {
                newString.append(srcStr.substring(0, first));
                srcStr = srcStr.substring(first + "_".length(), srcStr.length());
                srcStr = srcStr.toString().substring(0, 1).toUpperCase() + srcStr.substring(1);;
            }
        }
        newString.append(srcStr);
        return newString.toString();
    }

    /**
     * 类型转换
     * column.getValue()都是String类型，如果直接放入缓存之后会造成取出来类型异常
     * @param sqlType 数据库类型
     * @param value 值
     * @return 返回转换后的值
     */
    private static Object convertType(String sqlType,String value){
        int index = sqlType.indexOf("(");
        System.out.println(index+"下标++++++");
        //裁剪去除 （255）  int(11) 等带括号的类型
        Object newValue = null;
        if(index!=-1){
            sqlType = sqlType.substring(0,index);
        }
        System.out.println(sqlType);

        SimpleDateFormat simpleDateFormat;
        switch (sqlType){
//            case "bigint":
//                newValue = new BigInteger(value);
//                break;
            case "bit":
                newValue = Integer.parseInt(value) != 0;
                break;
            case "blob":
                newValue = value.getBytes();
                break;
            case "char":
            case "text":
            case "varchar":
                newValue = value;
                break;
            case "date":
                simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
                try {
                    newValue = simpleDateFormat.parse(value);
                } catch (ParseException e) {
                    e.printStackTrace();
                }
                break;
            case "timestamp":
            case "datetime":
                simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
                try {
                    newValue = Timestamp.valueOf(simpleDateFormat.format(simpleDateFormat.parse(value)));
                } catch (ParseException e) {
                    e.printStackTrace();
                }
                break;
            case "decimal":
                newValue = new BigDecimal(value);
                break;
            case "double":
                newValue = Double.parseDouble(value);;
                break;
            case "float":
                newValue = Float.parseFloat(value);
                break;
            case "int":
                newValue = Integer.parseInt(value);
                break;
            case "integer":
                newValue = Long.parseLong(value);
                break;
            default:
                break;
        }
        return newValue;
    }

}

CanalConnector connector = CanalConnectors.newSingleConnector(new InetSocketAddress("服务器IP",11111),"example","root","123456");
root是自己的数据库名称
123456数据库密码
example不需要更改对应了canal里面的配置文件
11111如果是docker则需要填写容器映射的端口11111:11111

直接获取Redis转为实体类。
实体类存到redis中会在前面自动加上

“@class”:“com.zsc.newbuds.entity.Admin”
com.zsc.newbuds.entity是包名
Admin是类名

所有在进行同步的时候我也进行了插入这个字段
在数据库表明第一个字母一般来说小写的，所以需要进行大写转换使其对应实体类（建议命名规则一致，这样可以减少很多麻烦）

//将第一个字母大写 应该对应自己的实体类 比如 数据库 user 实体类 User 数据库名建议使用驼峰命名  实体类第一个字母大写同样驼峰
// com.zsc.newbuds.entity  这个根据自己实体类的包名进行更改
 json.put("@class","com.zsc.newbuds.entity."+tableName.substring(0, 1).toUpperCase()+tableName.substring(1));

这个函数是将user_name转为驼峰命名，因为在实例类一般都使用驼峰命名，根据自己的实体类进行转变就好了。

    /**
     * 将 user_name 转为驼峰命名userName
     * @param srcStr user_name
     * @return 驼峰命名userName
     */
    private static String convertToString(String srcStr){
        StringBuilder newString = new StringBuilder();
        int first = 0;
        while (srcStr.contains("_")) {
            first = srcStr.indexOf("_");
            if (first != srcStr.length()) {
                newString.append(srcStr.substring(0, first));
                srcStr = srcStr.substring(first + "_".length(), srcStr.length());
                srcStr = srcStr.toString().substring(0, 1).toUpperCase() + srcStr.substring(1);;
            }
        }
        newString.append(srcStr);
        return newString.toString();
    }

这部分是对数据库类型转换为Java类型，有些没加上，可以自行添加。
sqlType是数据库的类型（小写形式）；
在int(11)会出现括号，这里去掉了括号的内容。

如果不进行类型转换存入json中的数据全部是字符串，然后获取的时候会出错
存入的效果

 /**
     * 类型转换
     * column.getValue()都是String类型，如果直接放入缓存之后会造成取出来类型异常
     * @param sqlType 数据库类型
     * @param value 值
     * @return 返回转换后的值
     */
    private static Object convertType(String sqlType,String value){
        int index = sqlType.indexOf("(");
        System.out.println(index+"下标++++++");
        //裁剪去除 （255）  int(11) 等带括号的类型
        Object newValue = null;
        if(index!=-1){
            sqlType = sqlType.substring(0,index);
        }
        System.out.println(sqlType);

        SimpleDateFormat simpleDateFormat;
        switch (sqlType){
//            case "bigint":
//                newValue = new BigInteger(value);
//                break;
            case "bit":
                newValue = Integer.parseInt(value) != 0;
                break;
            case "blob":
                newValue = value.getBytes();
                break;
            case "char":
            case "text":
            case "varchar":
                newValue = value;
                break;
            case "date":
                simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
                try {
                    newValue = simpleDateFormat.parse(value);
                } catch (ParseException e) {
                    e.printStackTrace();
                }
                break;
            case "timestamp":
            case "datetime":
                simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
                try {
                    newValue = Timestamp.valueOf(simpleDateFormat.format(simpleDateFormat.parse(value)));
                } catch (ParseException e) {
                    e.printStackTrace();
                }
                break;
            case "decimal":
                newValue = new BigDecimal(value);
                break;
            case "double":
                newValue = Double.parseDouble(value);;
                break;
            case "float":
                newValue = Float.parseFloat(value);
                break;
            case "int":
                newValue = Integer.parseInt(value);
                break;
            case "integer":
                newValue = Long.parseLong(value);
                break;
            default:
                break;
        }
        return newValue;
    }

这里列了几种，其他的对应和转换可以去百度下。

数据库类型	JAVA类型
bigint	java.math.BigInteger
bit	java.lang.Boolean
blob	java.lang.byte[]
char	java.lang.String
datetime	java.sql.Timestamp
date	java.sql.Date
decimal	java.math.BigDecimal
double	java.lang.Double
float	java.lang.Float
int	java.lang.Integer
text	java.lang.String
varchar	java.lang.String

在这部分可以进行redis操作

column.getName()			//获取列名
column.getMysqlType() 		//获取数据库中类型 int(11)
column.getValue()			//获取数据
tableName					//表名

测试

如果出现这些就代表成功了。

具体的建议根据自己的情况进行改变

打完收工

有什么疑问可以直接在评论区提问，我会第一时间进行解答（第一时间就是由我来定了）。希望你们可以有更好的方法。