蓝蓝站点

博客

发表于 更新于 分类于 ， ， Waline： 本文字数： 1.8k 阅读时长 ≈ 2 分钟

Java IO 合并多个二进制文件为一个二进制文件

背景

  • 我最近在调用讯飞语音的API来把我的博客中的文字转成音频,
  • 讯飞语音合成有数字限制,如果超过字数限制,会合成失败.
  • 为了不超过字数限制,我把文章分割成好几部分,分别合成,
  • 然后再把这些部分合并为一个文件.
  • 讯飞合成的音频文件是.pcm文件,这是个二进制文件,

好了,废话就说到这,下面介绍如何把多个二进制文件合并为一个二进制文件.

算法描述

复制文件的算法如下:

  • 从源文件中读入一些字节到内存(字节数组)中
  • 把内存中的这些字节写到目标文件中.

多个源文件合并成一个目标文件,算法跟复制文件差不多,算法描述如下:

  • 读取第一个源文件中的内容,输出到目标文件中.
  • 然后读取第二个源文件中的内容,然后输出到目标文件中.
  • 然后读取第三个源文件中的内容,然后输出到目标文件中.
  • 依次类推,直到处理所有的源文件完成。

关键代码

1
2
3
4
5
6
7
8
9
10
11
12
// 缓存数组
byte[] buffer = new byte[2048];
// 每次读入的字节数量
int inSize = -1;
// 批量读入字节到buffer缓存中,并返回读入的自己数量给inSize
// 这里的in为输入流对象
while ((inSize = in.read(buffer)) != -1)
{
    // 把buffer缓存中的字节写入输出流(也就是目标文件)
      // 这里的out为输出流对象  
    out.write(buffer, 0, inSize);
}

合并多个源文件到目标文件并删除源文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
/**
 * 合并文件ArrayList中的多个源文件为一个文件.
 * 
 * @param targetFilePath
 *            目标文件路径名称字符串.
 * @param sourceFilePathList
 *            存放源文件的路径名称字符串的ArrayList集合.
 */
public static void merge2TargetFileDeleteSourceFile(String targetFilePath,
        ArrayList<String> sourceFilePathList)
{
    // 如果ArrayList中有东西
    if (sourceFilePathList.size() > 0)
    {
        BufferedInputStream in;
        try (BufferedOutputStream out = new BufferedOutputStream(
                new FileOutputStream(new File(targetFilePath)));)
        {
            System.out.println("源文件列表:");
            for (Iterator<String> iterator = sourceFilePathList
                    .iterator(); iterator.hasNext();)
            {
                String sourceFilePath = iterator.next();
                System.out.println("    " + sourceFilePath);
                File sourceFile = new File(sourceFilePath);
                in = new BufferedInputStream(
                        new FileInputStream(sourceFile));
                // 缓存数组
                byte[] buffer = new byte[2048];
                // 每次读入的字节数量
                int inSize = -1;
                // 批量读入字节到buffer缓存中,并返回读入的自己数量给inSize
                while ((inSize = in.read(buffer)) != -1)
                {
                    // 把buffer缓存中的字节写入输出流(也就是目标文件)
                    out.write(buffer, 0, inSize);
                }
                // 关闭源文件
                in.close();
                // 删除这个源文件
                sourceFile.delete();
            }
        } catch (FileNotFoundException e)
        {
            e.printStackTrace();
        } catch (IOException e)
        {
            e.printStackTrace();
        }
    }
}

发表于 更新于 分类于 ， ， ， Waline： 本文字数： 325 阅读时长 ≈ 1 分钟

eclipse中字体的中英文大小不一致

分析原因

eclipse的默认字体好像是Consolas,但

Consolas字体原本是微软为 Visual Studio 2005和2008用户提供的，原版只是单独的英文字体，不含中文。因此在中文环境下显示会是“宋体”+Consolas 的组合。

解决方案

使用Consolas+雅黑混合版,下载路径https://www.iplaysoft.com/consolas.html

eclipse中使用

Window-Preferences-General-Appearance-Colors and fonts-Text Font,选择YaHei Consolas Hybrid,大小选择小四或者五号之类的带中文的字号.这两种字号比较清晰。

发表于 更新于 分类于 ， Waline： 本文字数： 6k 阅读时长 ≈ 5 分钟

反射调用方法步骤

  • 1.获取Class对象,使用Class.forName("类的全限定名")来加载类的实例,
  • 2.获取要调用的方法的Method对象,使用Class对象.getMethod("方法名",形参列表)获取要调用的方法.
  • 3.使用Method对象.invoke(该方法的拥有者,实参列表)调用方法.
    • 方法的拥有者可以是类和实例,
      • 如果是静态方法则拥有者设为类(Class对象),
      • 如果是实例方法,则方法的拥有者设置为实例(Object对象).这时就要求先创建好实例(Object对象).
        • 创建实例时,可以通过调用无参构造方法来创建。Class对象.newInstance()可以调用无参构造器,创建默认实例
        • 创建实例时,也可以调用带参构造器,通过Class对象.getConstructor(形参列表)可以创建一个指定的构造器(Constructor),然后调用Constructor对象.newInstance(实参列表);就可创建指定参数的实例.

实例

项目结构

1
2
3
4
5
6
E:\workspace_web2\TestReflect
└─src
  ├─test
  │ └─Test.java
  └─tools
    └─Tools.java

Tool.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
package tools;
public class Tools {
    String name;
    String sex;
    /**
     * @param name
     * @param sex
     */
    public Tools(String name, String sex)
    {
        super();
        this.name = name;
        this.sex = sex;
    }
    public static void publicStaticMethod()
    {
        System.out.println("公有 无参 静态 方法 被调用...");
    }
    public static void publicStaticMethod(String arg1, String arg2)
    {
        System.out.println("公有 带参 静态 方法 被调用...");
        System.out.println("    参数1:" + arg1 + ",参数2:" + arg2);
    }
    public void puablicInstanceMethod()
    {
        System.out.println("公有 无参 实例 方法 被调用...");
        System.out.println("Tools [name=" + name + ", sex=" + sex + "]");
    }
    public void puablicInstanceMethod(String arg1, String arg2)
    {
        System.out.println("公有 带参 实例 方法 被调用...");
        System.out.println("    参数1:" + arg1 + ",参数2:" + arg2);
    }
}

Tools.java中定义了一个带参的构造方法,以及无参的静态方法,带参的静态方法,无参的实例方法,带参的实例方法.下面使用反射来调用这些方法.

Test.java

使用反射会抛出大量的异常,但是本文的重点在于反射,所以我把所有的异常简单的抛出.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
package test;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
public class Test {
    public static void main(String[] args) throws Exception
    {
//         callPublicStaticMethod();
//         callPublicStaticMethod("Hello", "World");
//         callPublicInstanceMethod();
        callPublicInstanceMethod("Hello", "World");
    }
    private static void callPublicStaticMethod() throws Exception
    {
        Class<?> classIns = Class.forName("tools.Tools");
        // 获取不带参数的方法,
        // getMethod第一个参数是方法名称,后面是方法的形参列表
        Method method = classIns.getMethod("publicStaticMethod");
        // invoke方法的第一个参数是该方法的调用者,
        // 如果是静态方法,则设置调用者为类,
        // 如果是实例方法,则调用者为实例
        // invoke后面的参数是方法的实参列表,不需要参数可以省略.
        // 调用类classIns的无参静态方法
        method.invoke(classIns);
    }
    private static void callPublicStaticMethod(String arg1, String age2) throws Exception
    {
        Class<?> classIns = Class.forName("tools.Tools");
        // 获取不带参数的方法,
        // getMethod第一个参数是方法名称,后面是方法的形参列表
        Method method = classIns.getMethod("publicStaticMethod", String.class, String.class);
        // invoke方法的第一个参数是该方法的调用者,如果是静态方法,则设置调用者为类,如果是实例方法,则调用者为实例
        // invoke后面的参数是方法的实参列表,不需要参数可以不写
        // 调用类classIns的带参静态方法
        method.invoke(classIns, arg1, age2);
    }
    private static void callPublicInstanceMethod() throws Exception
    {
        // 获取类
        Class<?> class1 = Class.forName("tools.Tools");
        // 根据参数列表获取构造器
        Constructor<?> constructor = class1.getConstructor(String.class, String.class);
        // 创建对象
        Object object = constructor.newInstance("小明", "男");
        // 获取不带参数的方法,
        // getMethod第一个参数是方法名称,后面的参数是方法的形参列表,没有参数可以不写
        Method method = class1.getMethod("puablicInstanceMethod");
        // 调用实例object的puablicInstanceMethod方法.
        method.invoke(object);
    }
    private static void callPublicInstanceMethod(String arg1, String arg2) throws Exception
    {
        // 获取类
        Class<?> class1 = Class.forName("tools.Tools");
        // 根据参数列表获取构造器
        Constructor<?> constructor = class1.getConstructor(String.class, String.class);
        // 创建对象
        Object object = constructor.newInstance("小明", "男");
        // 获取不带参数的方法,
        // getMethod第一个参数是方法名称,后面的参数是方法的形参列表,没有参数可以不写
        Method method = class1.getMethod("puablicInstanceMethod", String.class, String.class);
        // invoke方法的第一个参数是该方法的调用者,
        // 如果是静态方法,则设置调用者为类,
        // 如果是实例方法,则调用者为实例
        // invoke后面的参数是方法的实参列表,
        // 调用实例object的puablicInstanceMethod方法.
        method.invoke(object, arg1, arg2);
    }
}

调用静态方法

调用无参的静态方法

1
2
3
4
5
6
7
8
9
10
11
private static void callPublicStaticMethod() throws Exception
{
    Class<?> classIns = Class.forName("tools.Tools");
    // 获取不带参数的方法,
    // getMethod第一个参数是方法名称,后面是方法的形参列表
    Method method = classIns.getMethod("publicStaticMethod");
    // invoke方法的第一个参数是该方法的调用者,如果是静态方法,则设置调用者为类,如果是实例方法,则调用者为实例
    // invoke后面的参数是方法的实参列表,不需要参数可以不写
    // 调用类classIns的无参静态方法
    method.invoke(classIns);
}

运行效果

1
公有 无参 静态 方法 被调用...

调用带参的静态方法

1
2
3
4
5
6
7
8
9
10
11
private static void callPublicStaticMethod(String arg1, String age2) throws Exception
{
    Class<?> classIns = Class.forName("tools.Tools");
    // 获取不带参数的方法,
    // getMethod第一个参数是方法名称,后面是方法的形参列表
    Method method = classIns.getMethod("publicStaticMethod", String.class, String.class);
    // invoke方法的第一个参数是该方法的调用者,如果是静态方法,则设置调用者为类,如果是实例方法,则调用者为实例
    // invoke后面的参数是方法的实参列表,不需要参数可以不写
    // 调用类classIns的带参静态方法
    method.invoke(classIns, arg1, age2);
}

运行效果

1
2
公有 带参 静态 方法 被调用...
    参数1:Hello,参数2:World

调用实例方法

调用无参实例方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
private static void callPublicInstanceMethod() throws Exception
{
    // 获取类
    Class<?> class1 = Class.forName("tools.Tools");
    // 根据参数列表获取构造器
    Constructor<?> constructor = class1.getConstructor(String.class, String.class);
    // 创建对象
    Object object = constructor.newInstance("小明", "男");
    // 获取不带参数的方法,
    // getMethod第一个参数是方法名称,后面的参数是方法的形参列表,没有参数可以不写
    Method method = class1.getMethod("puablicInstanceMethod");
    // 调用实例object的puablicInstanceMethod方法.
    method.invoke(object);
}

运行效果:

1
2
公有 无参 实例 方法 被调用...
Tools [name=小明, sex=男]

调用带参实例方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
private static void callPublicInstanceMethod(String arg1, String arg2) throws Exception
{
    // 获取类
    Class<?> class1 = Class.forName("tools.Tools");
    // 根据参数列表获取构造器
    Constructor<?> constructor = class1.getConstructor(String.class, String.class);
    // 创建对象
    Object object = constructor.newInstance("小明", "男");
    // 获取不带参数的方法,
    // getMethod第一个参数是方法名称,后面的参数是方法的形参列表,没有参数可以不写
    Method method = class1.getMethod("puablicInstanceMethod", String.class, String.class);
    // invoke方法的第一个参数是要调用方法的拥有者,后面剩下的参数是该方法的实参列表
    method.invoke(object, arg1, arg2);
}

运行效果:

1
2
公有 带参 实例 方法 被调用...
    参数1:Hello,参数2:World

发表于 更新于 分类于 ， ， ， Waline： 本文字数： 317 阅读时长 ≈ 1 分钟

eclipse暗色主题下SQL文件的配色

问题描述

eclipse的暗色主题下的SQL配色有问题,代码颜色和背景色对比不明显,看起来费神.如下图所示:
这里有一张图片

修改eclipse sql文件代码配色

windows->Preferences,然后在搜索框中输入Syntax Colorin,然后选择Data Management->SQL Editor->Syntax Coloring：
这里有一张图片
然后在右边Syntax items选择框中选择要修改的类型和Color选择框中选择对应的配色即可.
这里有一张图片

eclipse其他代码配色

同理:windows->Preferences,然后在搜索框中输入Syntax Colorin,然后选择对个的代码高亮设置即可.

发表于 更新于 分类于 ， ， ， Waline： 本文字数： 523 阅读时长 ≈ 1 分钟

eclipse中如何创建log4j文件

在项目src目录上右键,然后依次选择new,other…,XML,XML File,然后点击next,
这里有一张图片
然后选择要创建的路径,输入文件名log4j.xml,然后点击next
这里有一张图片
选择Create XML file from a DTD file,点击next。
这里有一张图片
选择Select XML Catalog entry,选中key为-//LOG4J//DTD LOG4J//EN的选项,然后点击next,
这里有一张图片
最后点击finish即可。
这里有一张图片
最后创建得到的xml代码如下:

1
2
3
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE log4j:configuration PUBLIC "-//LOG4J//DTD LOG4J//EN" "https://logging.apache.org/log4j/1.2/apidocs/org/apache/log4j/xml/doc-files/log4j.dtd" >
<log4j:configuration></log4j:configuration>

发表于 更新于 分类于 ， Waline： 本文字数： 2.5k 阅读时长 ≈ 2 分钟

如何读取src目录下的文件

src目录下的文件都是资源文件,运行程序时,可以通过反射来获取这些资源文件的输入流,进而读取这些文件中的内容。
放到src目录下的文件会被打包到jar包中。

我的用法

平常会用到好多代码模板,我会把这些代码的模板放到src目录下,这样当打包成可执行jar的时候,这些代码会被打包到jar文件中。
以后我要获取这些代码模板时候.我只需要运行这个可执行jar包.然后通过命令行参数确定我要使用哪个模板文件,然后程序读取jar包中的这个模板文件的内容,然后输出到剪贴板上.
这样我就直接粘贴即可使用这些代码模板。

读取资源文件的工具类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
/**
 * 这个类专门用来读取资源文件
 */
public class ResourceFileReader
{
     public static void main(String[] args)
     {
     System.out.println(getResourceFileContent("/AudioPlay.html", "utf-8"));
     }
    /**
     * 
     * /** 读入资源目录下的path文件中的内容.会以UTF-8编码来读取,所以该文件必须要保存为UTF-8编码格式.
     * 
     * @param path
     *            资源文件的路径,必须以<code>/</code>开头.<br>
     *            例如项目资源目录res下的的<code>AudioPlay.html</code>的路径为:
     *            <code>"/AudioPlay.html"</code>
     * @return 资源目录下的path文件的内容
     */
    public static String getResourceFileContent(String path, String charset)
    {
        if (path.startsWith("/"))
        {
            String content = null;
            // TODO Auto-generated method stub
            InputStream inputStream = ResourceFileReader.class
                    .getResourceAsStream(path);
            try (BufferedReader reader = new BufferedReader(
                    new InputStreamReader(inputStream, charset));)
            {
                StringBuilder builder = new StringBuilder();
                char[] charArray = new char[200];
                int number = -1;
                while ((number = reader.read(charArray)) != -1)
                {
                    builder.append(charArray, 0, number);
                }
                content = builder.toString();
                // System.out.println(builder.toString());
            } catch (FileNotFoundException e)
            {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } catch (IOException e)
            {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            return content;
        }
        return null;
    }
}

使用示例

例如现在有一个MybatisMapperTemplete.xml文件，路径/CodeGenerator/src/res/MybatisMapperTemplete.xml,内容如下:

1
2
3
4
5
<?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" >
<mapper namespace="">

</mapper>

现在使用上面的工具类来读取这个资源文件.

需要注意的是:资源文件的路径是相对于src目录的路径.也就是把src/作为根路径/,从而得到的路径为:/res/MybatisMapperTemplete.xml
然后调用上面的工具方法即可读取该文件中的内容:

1
2
3
4
5
public static void main(String[] args)
{
    System.out.println(
        ResourceFileReader.getResourceFileContent("/res/MybatisMapperTemplete.xml", "utf-8"));
}

控制台会输出该文件中的内容,如下所示:

1
2
3
4
5
<?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" >
<mapper namespace="">

</mapper>

发表于 更新于 分类于 ， ， Waline： 本文字数： 2.7k 阅读时长 ≈ 2 分钟

Type interface mapper.UserMapper is not known to the MapperRegistry.

1
2
3
4
5
org.apache.ibatis.binding.BindingException: Type interface mapper.UserMapper is not known to the MapperRegistry.
    at org.apache.ibatis.binding.MapperRegistry.getMapper(MapperRegistry.java:47)
    at org.apache.ibatis.session.Configuration.getMapper(Configuration.java:745)
    at org.apache.ibatis.session.defaults.DefaultSqlSession.getMapper(DefaultSqlSession.java:292)
    at test.ManyToManyTest.main(ManyToManyTest.java:18)

分1:没有引入Mapper.xml

这是因为没有在mybatis-config.xml中引入UserMapper.xml.

解决

在mybatis根配置文件mybatis-config.xml中,引入UserMapper.xml即可:<mapper resource="mapper/UserMapper.xml"/>

1
2
3
4
5
6
7
8
9
<?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>
    ......
    <mappers>
        <mapper resource="mapper/UserMapper.xml"/>
    </mappers>
    ......
</configuration>

分析2:没有引入Mapper接口路径

解决

引入StudentMapper.java接口即可:

1
2
3
4
5
6
7
8
9
10
11
12
13
<?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">
<!-- 该配置文件包含对 MyBatis 系统的核心设置 -->
<configuration>
    ......
    <mappers>
        <mapper class="mapper.ClazzMapper"/>
        <mapper class="mapper.StudentMapper"/>
    </mappers>
    ......
</configuration>

总结

引入Mapper.xml映射文件,使用resource属性,而引入接口则使用class属性.

Table ‘mybatis.tb_calzz’ doesn’t exist

错误提示

1
2
3
4
5
6
7
8
9
10
DEBUG [main] ==>  Preparing: select * from tb_student where id=? 
DEBUG [main] ==> Parameters: 1(Integer)
DEBUG [main] ====>  Preparing: select * from tb_calzz where id=? 
DEBUG [main] ====> Parameters: 1(Integer)
org.apache.ibatis.exceptions.PersistenceException: 
### Error querying database.  Cause: com.mysql.jdbc.exceptions.jdbc4.MySQLSyntaxErrorException: Table 'mybatis.tb_calzz' doesn't exist
### The error may exist in mapper/ClazzMapper.java (best guess)
### The error may involve mapper.ClazzMapper.selectClazzById-Inline
### The error occurred while setting parameters
### SQL: select * from tb_calzz where id=?

分析

提示很明显,说mybatis数据库中不存在tb_calzz这个表.这种情况:

  • 要么是这个表不存在,如果是这样,创建进入数据库,创建这个表即可。
  • 要么是SQL中这个表名字打错了,这种情况,修改SQL语句,把表名改为正确的表名即可.

Error querying database. …Query was empty

1
2
3
4
5
6
org.apache.ibatis.exceptions.PersistenceException: 
### Error querying database.  Cause: com.mysql.jdbc.exceptions.jdbc4.MySQLSyntaxErrorException: Query was empty
### The error may exist in mapper/UserMapper.xml
### The error may involve mapper.UserMapper.selectUserById-Inline
### The error occurred while setting parameters
### SQL:

原因

映射文件mapper/UserMapper.xml中id为selectUserById的select标签中没有写SQL语句。

解决

写上SQL语句即可。

发表于 更新于 分类于 ， ， Waline： 本文字数： 1.4k 阅读时长 ≈ 1 分钟

eclipse 创建mybatis-config.xml 创建mapper.xml文件

下载mybatis的jar包

这里不介绍如何下载mybatis的jar包,我这里用的版本是:mybatis-3.4.5. jar.

从mybatis的jar包复制模板文件

用解压工具打开jar包,进入mybatis-3.4.5. jar\org\apache\ibatis\builder\xml\目录,然后复制mybatis-3-config.dtd,mybatis-3-mapper.dtd这两个文件.
这里有一张图片

保存模板文件到本地

打开eclipse的安装目录,然后创建一个名为mybatis_config目录,进入该目录,然后粘贴上面复制的两个文件:
这里有一张图片
这个文件你想粘贴到哪里都无所谓,只要记得粘贴的路径即可,,我粘贴到eclipse安装目录中主要是为了,方便后面管理和使用.

引入模板文件到eclipse中

引入mybatis-3-config.dtd

依次点开Window-Preferences-XML-XML Catalog,然后点击Add按钮,在弹出的窗口中选择Catalog Entry,然后点击右边的File System...按钮：
这里有一张图片
找到刚才粘贴的文件mybatis-3-config.dtd:
这里有一张图片
然后在key文本框中输入下面代码:

1
-//mybatis.org//DTD Config 3.0//EN

然后勾选Alternative web address:,并在下面的文本框输入一下地址:

1
http://mybatis.org/dtd/mybatis-3-config.dtd

如下图所示:
这里有一张图片
最后点击OK即可.

引入mybatis-3-mapper.dtd

引入mybatis-3-mapper.dtd类似上面,只是此时的key改为如下:

1
-//mybatis.org//DTD Mapper 3.0//EN

然后勾选Alternative web address:,并在下面的文本框输入一下地址:

1
http://mybatis.org/dtd/mybatis-3-mapper.dtd

如下图所示:
这里有一张图片
这样引入就完成了

使用模板文件创建mybatis-config.xml文件

在src目录上右键,选择New-Other...,然后展开XML目录,选择XML File,然后Next
这里有一张图片
输入文件名mybatis-config.xml,然后Next
这里有一张图片
选择Create XML file from a DTD file:
这里有一张图片
然后勾选Select XML Catalog entry,在选择框中选择:-//mybatis. org//DTD Config 3.0//EN,然后Next.
这里有一张图片
然后点击Finish,这样就创建好了mybatis-config.xml文件了,如下图所示:
这里有一张图片
自动生成的代码如下:

1
2
3
<?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></configuration>

创建Mapper.xml类似

发表于 更新于 分类于 ， ， ， Waline： 本文字数： 219 阅读时长 ≈ 1 分钟

打开eclipse marketplace

这里有一张图片

安装mybatis-generator

插件主页

打开链接:https://marketplace.eclipse.org/content/mybatis-generator
注意看版本是否对应.

拖动安装插件

点击install按钮,拖动到eclipse marketplace上.
这里有一张图片
然后eclipse marketplace会自动下载mybatis-generator

同意许可

这里有一张图片
安装完毕后重启eclipse即可.

发表于 更新于 分类于 ， Waline： 本文字数： 4.6k 阅读时长 ≈ 4 分钟

Java网络编程 TCP编程 发送接收对象 对象序列化反序列化

对象序列化

前提条件:必须实现java.io.Serializable接口.

1
2
3
4
5
6
7
8
9
//ObjectOutputStream(OutputStream out)
// 1.所以传入的参数正确就行,我这里是对服务器的输出流
outputToServer = new ObjectOutputStream(client.getOutputStream());
// 2.把命令行参数序列化到服务器
outputToServer.writeObject(args);
// 3.一定要刷新,对象不会发送出去
outputToServer.flush();
// 4.在最后关闭
//outputToServer.close();

对象反序列化

1
2
3
4
// 接收服务端的序列化信息
inputByServer = new ObjectInputStream(client.getInputStream());
// 反序列化成对象(字符串数组)
String[] inputArg = (String[]) inputByServer.readObject();

实例

通信流程

客户端和服务端通信流程如下
客户端会把接收到的命令行参数(String数组)发送给服务端,
服务端接收该字符串数组,然后、打印到服务端的控制台上,并把这个字符串数组原样发送给客户端,
然后客户端接收服务端发送过来的字符串数组,转换之后打印到控制台上.

服务端主线程

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
package tcp.arg;
import java.net.ServerSocket;
import java.net.Socket;
public class EchoThreadServerByArgs
{
    // 静态变量,可以更改该标记以便停止服务端
    private static boolean isServerAlive = true;
    private static int clientNum = 0;
    public static void main(String args[]) throws Exception
    {
        // 1.定义服务器的引用
        ServerSocket server = null;
        // 2.客户端的引用
        Socket client = null;
        // 3.建立服务器，监听本地6666端口
        server = new ServerSocket(6666);
        while (isServerAlive)
        {
            System.out.println("等待客户端连接...");
            // 4.取得连接，客户端没连接之前先等待连接。
            client = server.accept();
            System.out.println("    客户端连接成功,当前客户端数量:" + clientNum);
            if (isServerAlive)
            {
                // 一个客户端连接之后，为该客户端启动一个服务线程进行服务
                new Thread(new EchoThreadByArgs(client)).start();
            }
        }
        server.close();
        client.close();
        System.out.println("服务端已经停止...");
    }
    public static void addClientNum()
    {
        clientNum = clientNum + 1;
        // 注意了,下面的赋值方法错误
        // 后++:先取值,再增加,这将达不到增加的效果
        // clientNum = clientNum ++;
    }
    public static void minusClientNum()
    {
        clientNum = clientNum - 1;
    }
    public static int getClientNum()
    {
        return clientNum;
    }
    public static void shutdownServer()
    {
        isServerAlive = false;
    }
    public static boolean isServerAlive()
    {
        return isServerAlive;
    }
}

服务端响应线程

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
package tcp.arg;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.net.Socket;
import tcp.EchoThreadServer;
public class EchoThreadByArgs implements Runnable
{
    // 客户端引用
    private Socket client = null;
    int clienId;
    // 构造函数
    public EchoThreadByArgs(Socket client)
    {
        this.client = client;
        // 设置服务线程编号
        this.clienId = EchoThreadServer.getClientNum();
        // 服务线程数量加1
        EchoThreadServer.addClientNum();
    }
    // 线程执行体
    public void run()
    {
        // 接收客户端的输入
        ObjectInputStream inoutFromClient = null;
        ObjectOutputStream outputToClient = null;
        try
        {
            // 接收客户端的输入
            inoutFromClient = new ObjectInputStream(client.getInputStream());
            String[] inputArg = (String[]) inoutFromClient.readObject();
            for (String string : inputArg)
            {
                System.out.println(string);
            }
            // 输出对象到客户端
            outputToClient = new ObjectOutputStream(client.getOutputStream());
            outputToClient.writeObject(inputArg);
            // 一定要刷新,不然客户端接收不到
            outputToClient.flush();
        } catch (Exception e)
        {
            e.printStackTrace();
        } finally
        {
            if (inoutFromClient != null)
            {
                try
                {
                    inoutFromClient.close();
                } catch (IOException e)
                {
                }
            }
            if (outputToClient != null)
            {
                try
                {
                    outputToClient.close();
                } catch (IOException e)
                {
                }
            }
        }
    }
}

客户端线程

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
package tcp.arg;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.net.Socket;
import java.net.UnknownHostException;
public class EchoClientByArgs
{
    public static void main(String[] args)
    {
        // 定义客户端引用
        Socket client = null;
        try
        {
            // 创建客户端监听本机的6666端口
            client = new Socket("localhost", 6666);
        } catch (UnknownHostException e)
        {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e)
        {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        ObjectOutputStream outputToServer = null;
        ObjectInputStream inputByServer = null;
        try
        {
            outputToServer = new ObjectOutputStream(client.getOutputStream());
            // 把命令行参数序列化到服务器
            outputToServer.writeObject(args);
            outputToServer.flush();
            // 注意先后顺序,一定要写在发送之前
            // 接收服务端的序列化信息
            inputByServer = new ObjectInputStream(client.getInputStream());
            // 反序列化成对象(字符串数组)
            String[] inputArg = (String[]) inputByServer.readObject();
            // 遍历数组
            for (String string : inputArg)
            {
                System.out.println(string);
            }
        } catch (IOException | ClassNotFoundException e)
        {
            e.printStackTrace();
        } finally
        {
            if (outputToServer != null)
            {
                try
                {
                    outputToServer.close();
                } catch (IOException e)
                {
                }
            }
            if (inputByServer != null)
            {
                try
                {
                    inputByServer.close();
                } catch (IOException e)
                {
                }
            }
        }
    }
}

运行效果

这里有一张图片