一切福田，不離方寸，從心而覓，感無不通。

Category Archives: Java

C#中TripleDES对应Java中的DESede即大家说的3DES，附C#及Java加解密结果一致的控制台程序例子

直接上代码了。 Java控制台代码： package Test; import java.security.Key; import javax.crypto.Cipher; import javax.crypto.SecretKeyFactory; import javax.crypto.spec.DESedeKeySpec; import javax.crypto.spec.IvParameterSpec; import org.apache.commons.codec.binary.Base64; public class Test { private static final String encoding = "UTF-8"; public static void main(String[] args) { try { String text = "20200121";// 明文 String key = "Tt3rLPrDIVIhXqAz";// 长度控制为16，作为3DES加密用的key String encryptStr = EncryptData(text, key);// 3DES加密结果 System.out.println("明文：" + text); System.out.println("密钥：" + key); System.out.println("密文：" + encryptStr); System.out.println("解密：" + DecryptData(encryptStr, key)); } catch (Exception e) { e.printStackTrace(); } } /** * DESede加密，key长度为16 * * @param plainText 明文 * @param key 密钥 * @return DESede加密结果 * […]

龙生   09 May 2020
View Details

Springboot调用soap webservice（Client）

1.使用jdk自带的webservice工具wsimport生成相关类 测试wsdl http://www.webxml.com.cn/WebServices/IpAddressSearchWebService.asmx?wsdl

1
wsimport -s d:\wsdl -p com.example.demo.request -encoding utf-8 http://www.webxml.com.cn/WebServices/IpAddressSearchWebService.asmx?wsdl

  -s 存储目录； -p 包名； -encoding 文件编码，默认会采用操作系统编码，中文为gbk，建议使用utf-8； 2.构建相关的配置类及测试方法

1
2
3
4
5
6
7
8
@Configuration
public class IpConfig {
 
    @Bean
    public IpAddressSearchWebServiceSoap webService(){
        return new IpAddressSearchWebService().getIpAddressSearchWebServiceSoap();
    }
}

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
@SpringBootApplication
@RestController
@RequestMapping("/soap")
public class DemoApplication {
 
    @Autowired
    private IpAddressSearchWebServiceSoap soap;
 
    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }
 
    @RequestMapping("/{ip}")
    public ArrayOfString searchIp(@PathVariable("ip") String ip) {
        ArrayOfString response = soap.getCountryCityByIp(ip);
        return response;
    }
}

    from:https://blog.csdn.net/VitaminZH/article/details/81123571

龙生   30 Mar 2020
View Details

恕我直言，我怀疑你没怎么用过枚举

我们是否一样？ 估计很多小伙伴（也包括我自己）都有这种情况，在自学Java语言看书时，关于枚举enum这一块的知识点可能都有点 “轻敌” ，觉得这块内容非常简单，一带而过，而且在实际写代码过程中也不注意运用。 是的，我也是这样！直到有一天我提的代码审核没过，被技术总监一顿批，我才重新拿起了《Java编程思想》，把枚举这块的知识点重新又审视了一遍。 为什么需要枚举 常量定义它不香吗？为啥非得用枚举？ 举个栗子，就以B站上传视频为例，视频一般有三个状态：草稿、审核和发布，我们可以将其定义为静态常量：

1
2
3
4
5
6
7
8
public class VideoStatus {
    
    public static final int Draft = 1; //草稿
    
    public static final int Review = 2; //审核
    
    public static final int Published = 3; //发布
}

  对于这种单值类型的静态常量定义，本身也没错，主要是在使用的地方没有一个明确性的约束而已，比如：

1
2
3
4
5
void judgeVideoStatus( int status ) {
    
    ...
    
}

  比如这里的 judgeVideoStatus 函数的本意是传入 VideoStatus 的三种静态常量之一，但由于没有类型上的约束，因此传入任意一个int值都是可以的，编译器也不会提出任何警告。 但是在枚举类型出现之后，上面这种情况就可以用枚举严谨地去约束，比如用枚举去定义视频状态就非常简洁了：

1
2
3
public enum VideoStatus {
    Draft, Review, Published
}

  而且主要是在用枚举的地方会有更强的类型约束：

1
2
3
4
5
6
// 入参就有明确类型约束
void judgeVideoStatus( VideoStatus status ) {
    
    ...
    
}

  这样在使用 judgeVideoStatus 函数时，入参类型就会受到明确的类型约束，一旦传入无效值，编译器就会帮我们检查，从而规避潜在问题。 除此之外，枚举在扩展性方面比普常量更方便、也更优雅。 重新系统认识一下枚举 还是拿前文《答应我，别再if/else走天下了可以吗》中的那个例子来说：比如，在后台管理系统中，肯定有用户角色一说，而且角色一般都是固定的，适合定义成一个枚举：

1
2
3
4
5
6
7
8
public enum UserRole {
 
    ROLE_ROOT_ADMIN,  // 系统管理员
 
    ROLE_ORDER_ADMIN, // 订单管理员
 
    ROLE_NORMAL       // 普通用户
}

  接下来我们就用这个UserRole为例来说明枚举的所有基本用法：

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
UserRole role1 = UserRole.ROLE_ROOT_ADMIN;
UserRole role2 = UserRole.ROLE_ORDER_ADMIN;
UserRole role3 = UserRole.ROLE_NORMAL;
 
// values()方法：返回所有枚举常量的数组集合
for ( UserRole role : UserRole.values() ) {
    System.out.println(role);
}
// 打印：
// ROLE_ROOT_ADMIN
// ROLE_ORDER_ADMIN
// ROLE_NORMAL
 
// ordinal()方法：返回枚举常量的序数，注意从0开始
System.out.println( role1.ordinal() ); // 打印0
System.out.println( role2.ordinal() ); // 打印1
System.out.println( role3.ordinal() ); // 打印2
 
// compareTo()方法：枚举常量间的比较
System.out.println( role1.compareTo(role2) ); //打印-1
System.out.println( role2.compareTo(role3) ); //打印-2
System.out.println( role1.compareTo(role3) ); //打印-2
 
// name()方法：获得枚举常量的名称
System.out.println( role1.name() ); // 打印ROLE_ROOT_ADMIN
System.out.println( role2.name() ); // 打印ROLE_ORDER_ADMIN
System.out.println( role3.name() ); // 打印ROLE_NORMAL
 
// valueOf()方法：返回指定名称的枚举常量
System.out.println( UserRole.valueOf( "ROLE_ROOT_ADMIN" ) );
System.out.println( UserRole.valueOf( "ROLE_ORDER_ADMIN" ) );
System.out.println( UserRole.valueOf( "ROLE_NORMAL" ) );

  除此之外，枚举还可以用于switch语句中，而且意义更加明确：

1
2
3
4
5
6
7
8
9
10
11
12
UserRole userRole = UserRole.ROLE_ORDER_ADMIN;
switch (userRole) {
    case ROLE_ROOT_ADMIN:  // 比如此处的意义就非常清晰了，比1，2，3这种数字好！
        System.out.println("这是系统管理员角色");
        break;
    case ROLE_ORDER_ADMIN:
        System.out.println("这是订单管理员角色");
        break;
    case ROLE_NORMAL:
        System.out.println("这是普通用户角色");
        break;
}

  自定义扩充枚举 上面展示的枚举例子非常简单，仅仅是单值的情形，而实际项目中用枚举往往是多值用法。 比如，我想扩充一下上面的UserRole枚举，在里面加入 角色名 — 角色编码 的对应关系，这也是实际项目中常用的用法。 这时候我们可以在枚举里自定义各种属性、构造函数、甚至各种方法：

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
public enum UserRole {
 
    ROLE_ROOT_ADMIN( "系统管理员", 000000 ),
    ROLE_ORDER_ADMIN( "订单管理员", 100000 ),
    ROLE_NORMAL( "普通用户", 200000 ),
    ;
 
    // 以下为自定义属性
    
    private final String roleName;  //角色名称
 
    private final Integer roleCode; //角色编码
 
    // 以下为自定义构造函数
    
    UserRole( String roleName, Integer roleCode ) {
        this.roleName = roleName;
        this.roleCode = roleCode;
    }
 
    // 以下为自定义方法
    
    public String getRoleName() {
        return this.roleName;
    }
 
    public Integer getRoleCode() {
        return this.roleCode;
    }
 
    public static Integer getRoleCodeByRoleName( String roleName ) {
        for( UserRole enums : UserRole.values() ) {
            if( enums.getRoleName().equals( roleName ) ) {
                return enums.getRoleCode();
            }
        }
        return null;
    }
 
}

  从上述代码可知，在enum枚举类中完全可以像在普通Class里一样声明属性、构造函数以及成员方法。 枚举 + 接口 = ? 比如在我的前文《答应我，别再if/else走天下了可以吗》中讲烦人的if/else消除时，就讲过如何通过让枚举去实现接口来方便的完成。 这地方不妨再回顾一遍： 什么角色能干什么事，这很明显有一个对应关系，所以我们首先定义一个公用的接口RoleOperation，表示不同角色所能做的操作：

1
2
3
public interface RoleOperation {
    String op();  // 表示某个角色可以做哪些op操作
}

  接下来我们将不同角色的情况全部交由枚举类来做，定义一个枚举类RoleEnum，并让它去实现RoleOperation接口：

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
public enum RoleEnum implements RoleOperation {
 
    // 系统管理员(有A操作权限)
    ROLE_ROOT_ADMIN {
        @Override
        public String op() {
            return "ROLE_ROOT_ADMIN:" + " has AAA permission";
        }
    },
 
    // 订单管理员(有B操作权限)
    ROLE_ORDER_ADMIN {
        @Override
        public String op() {
            return "ROLE_ORDER_ADMIN:" + " has BBB permission";
        }
    },
 
    // 普通用户(有C操作权限)
    ROLE_NORMAL {
        @Override
        public String op() {
            return "ROLE_NORMAL:" + " has CCC permission";
        }
    };
}

  这样，在调用处就变得异常简单了，一行代码就行了，根本不需要什么if/else：

1
2
3
4
5
6
public class JudgeRole {
    public String judge( String roleName ) {
        // 一行代码搞定！之前的if/else灰飞烟灭
        return RoleEnum.valueOf(roleName).op();
    }
}

  而且这样一来，以后假如我想扩充条件，只需要去枚举类中加代码即可，而不用改任何老代码，非常符合开闭原则！ 枚举与设计模式 什么？枚举还能实现设计模式？ 是的！不仅能而且还能实现好几种！ 1、单例模式

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
public class Singleton {
 
    // 构造函数私有化，避免外部创建实例
    private Singleton() {
 
    }
 
    //定义一个内部枚举
    public enum SingletonEnum{
 
        SEED;  // 唯一一个枚举对象，我们称它为“种子选手”！
 
        private Singleton singleton;
 
        SingletonEnum(){
            singleton = new Singleton(); //真正的对象创建隐蔽在此！
        }
 
        public Singleton getInstnce(){
            return singleton;
        }
    }
 
    // 故意外露的对象获取方法，也是外面获取实例的唯一入口
    public static Singleton getInstance(){
        return SingletonEnum.SEED.getInstnce(); // 通过枚举的种子选手来完成
    }
}

  2、策略模式 这个也比较好举例，比如用枚举就可以写出一个基于策略模式的加减乘除计算器

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
public class Test {
 
    public enum Calculator {
 
        ADDITION {
            public Double execute( Double x, Double y ) {
                return x + y; // 加法
            }
        },
 
        SUBTRACTION {
            public Double execute( Double x, Double y ) {
                return x - y; // 减法
            }
        },
 
        MULTIPLICATION {
            public Double execute( Double x, Double y ) {
                return x * y; // 乘法
            }
        },
 
 
        DIVISION {
            public Double execute( Double x, Double y ) {
                return x/y;  // 除法
            }
        };
 
        public abstract Double execute(Double x, Double y);
    }
    
    public static void main(String[] args) {
        System.out.println( Calculator.ADDITION.execute( 4.0, 2.0 ) );      
        // 打印 6.0
        System.out.println( Calculator.SUBTRACTION.execute( 4.0, 2.0 ) );    
        // 打印 2.0
        System.out.println( Calculator.MULTIPLICATION.execute( 4.0, 2.0 ) );
        // 打印 8.0
        System.out.println( Calculator.DIVISION.execute( 4.0, 2.0 ) );      
        // 打印 2.0
    }
}

  专门用于枚举的集合类 我们平常一般习惯于使用诸如：HashMap 和 HashSet等集合来盛放元素，而对于枚举，有它专门的集合类：EnumSet和EnumMap 1、EnumSet EnumSet 是专门为盛放枚举类型所设计的 Set 类型。 还是举例来说，就以文中开头定义的角色枚举为例：

1
2
3
4
5
6
7
8
public enum UserRole {
 
    ROLE_ROOT_ADMIN,  // 系统管理员
 
    ROLE_ORDER_ADMIN, // 订单管理员
 
    ROLE_NORMAL       // 普通用户
}

  比如系统里来了一批人，我们需要查看他是不是某个角色中的一个：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
// 定义一个管理员角色的专属集合
EnumSet<UserRole> userRolesForAdmin
    = EnumSet.of(
        UserRole.ROLE_ROOT_ADMIN,
        UserRole.ROLE_ORDER_ADMIN
    );
 
// 判断某个进来的用户是不是管理员
Boolean isAdmin( User user ) {
    
    if( userRoles.contains( user.getUserRole() ) )
        return true;
    
    return false;
}

  2、EnumMap 同样，EnumMap 则是用来专门盛放枚举类型为key的 Map 类型。 比如，系统里来了一批人，我们需要统计不同的角色到底有多少人这种的话：

1
2
3
4
5
6
7
8
9
10
Map<UserRole,Integer> userStatisticMap = new EnumMap<>(UserRole.class);
 
for ( User user : userList ) {
    Integer num = userStatisticMap.get( user.getUserRole() );
    if( null != num ) {
        userStatisticMap.put( user.getUserRole(), num+1 );
    } else {
        userStatisticMap.put( user.getUserRole(), 1 );
    }
}

  用EnumMap可以说非常方便了。 总 结 小小的枚举就玩出这么多的花样，不过好在探索和总结的过程还挺有意思的，也复习了很多知识，慢慢来吧。   from:https://my.oschina.net/hansonwang99/blog/3196498

龙生   25 Mar 2020
View Details

centos7查看JAVA_HOME

windows： set java_home:查看JDK安装路径 java -version:查看JDK版本 linux： whereis java which java （java执行路径） echo $JAVA_HOME echo $PATH from:https://blog.csdn.net/Xin7Xin/article/details/86304542

龙生   27 Dec 2019
View Details

java:bytes[]转long的三种方式

bytes[] 到数字类型的转换是个经常用到的代码,解决方式也不止一种，最近需要将bytes[]转为long,有机会深入了解了一下，此文做个总结。 java代码实现 如果不想借助任何已经有的类，完全可以自己实现这段代码，如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
    /**
     * 将字节数组转为long<br>
     * 如果input为null,或offset指定的剩余数组长度不足8字节则抛出异常
     * @param input
     * @param offset 起始偏移量
     * @param littleEndian 输入数组是否小端模式
     * @return
     */
    public static long longFrom8Bytes(byte[] input, int offset, boolean littleEndian){
        long value=0;
        // 循环读取每个字节通过移位运算完成long的8个字节拼装
        for(int  count=0;count<8;++count){
            int shift=(littleEndian?count:(7-count))<<3;
            value |=((long)0xff<< shift) & ((long)input[offset+count] << shift);
        }
        return value;
    }

借助java.nio.ByteBuffer实现 java.nio.ByteBuffer 本身就有getLong,getInt,getFloat….方法,只要将byte[]转换为ByteBuffer就可以实现所有primitive类型的数据读取,参见javadoc。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
    /**
     * 利用 {@link java.nio.ByteBuffer}实现byte[]转long
     * @param input
     * @param offset
     * @param littleEndian 输入数组是否小端模式
     * @return
     */
    public static long bytesToLong(byte[] input, int offset, boolean littleEndian) {
        // 将byte[] 封装为 ByteBuffer
        ByteBuffer buffer = ByteBuffer.wrap(input,offset,8);
        if(littleEndian){
            // ByteBuffer.order(ByteOrder) 方法指定字节序,即大小端模式(BIG_ENDIAN/LITTLE_ENDIAN)
            // ByteBuffer 默认为大端(BIG_ENDIAN)模式
            buffer.order(ByteOrder.LITTLE_ENDIAN);
        }
        return buffer.getLong();  
    }

  借助java.io.DataInputStream实现 java.io.DataInputStream 同样提供了readLong,readLong,readLong….方法,只要将byte[]转换为DataInputStream就可以实现所有primitive类型的数据读取,参见javadoc。 完整测试代码 下面的Junit 测试代码计算String 的MD5校验码(16 bytes),然后使用上述方式分别将16 bytes转换为2个long(大端模式)然后以16进制模式输出结果,以验证三种方式一致性。

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
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
package net.gdface.facelog;
 
import java.io.ByteArrayInputStream;
import java.io.DataInputStream;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import org.junit.Test;
 
 
public class TestSerialVersionUID {
    /**
     * 生成MD5校验码
     *
     * @param source
     * @return
     */
    static public byte[] getMD5(byte[] source) {
        if (null==source)
            return null;
        try {
            MessageDigest md = MessageDigest.getInstance("MD5");
            return md.digest(source);
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        }
        return null;
    }
    /**
     * 将16位byte[] 转换为32位的HEX格式的字符串String
     *
     * @param buffer
     * @return
     */
    static public String toHex(byte buffer[]) {
        if (null==buffer)
            return null;
        StringBuffer sb = new StringBuffer(buffer.length * 2);
        for (int i = 0; i < buffer.length; i++) {
            sb.append(Character.forDigit((buffer[i] & 240) >> 4, 16));
            sb.append(Character.forDigit(buffer[i] & 15, 16));
        }
        return sb.toString();
    }
 
    /**
     * 将字节数组转为long<br>
     * 如果input为null,或offset指定的剩余数组长度不足8字节则抛出异常
     * @param input
     * @param offset 起始偏移量
     * @param littleEndian 输入数组是否小端模式
     * @return
     */
    public static long longFrom8Bytes(byte[] input, int offset, boolean littleEndian){
        if(offset <0 || offset+8>input.length)
            throw new IllegalArgumentException(String.format("less than 8 bytes from index %d  is insufficient for long",offset));
        long value=0;
        for(int  count=0;count<8;++count){
            int shift=(littleEndian?count:(7-count))<<3;
            value |=((long)0xff<< shift) & ((long)input[offset+count] << shift);
        }
        return value;
    }
 
    /**
     * 利用 {@link java.nio.ByteBuffer}实现byte[]转long
     * @param input
     * @param offset
     * @param littleEndian 输入数组是否小端模式
     * @return
     */
    public static long bytesToLong(byte[] input, int offset, boolean littleEndian) {
        if(offset <0 || offset+8>input.length)
            throw new IllegalArgumentException(String.format("less than 8 bytes from index %d  is insufficient for long",offset));
        ByteBuffer buffer = ByteBuffer.wrap(input,offset,8);
        if(littleEndian){
            // ByteBuffer.order(ByteOrder) 方法指定字节序,即大小端模式(BIG_ENDIAN/LITTLE_ENDIAN)
            // ByteBuffer 默认为大端(BIG_ENDIAN)模式
            buffer.order(ByteOrder.LITTLE_ENDIAN);
        }
        return buffer.getLong();  
    }
    @Test
    public void test() throws IOException {
        String input="net.gdface.facelog.dborm.person.FlPersonBeanBase";
        byte[] md5 = getMD5(input.getBytes());
        System.out.printf("md5 [%s]\n",toHex(md5));
        // 三种方式运算结果对比验证
        DataInputStream dataInput = new DataInputStream(new ByteArrayInputStream(md5));
        long l1 = dataInput.readLong();
        long l2 = dataInput.readLong();
        System.out.printf("l1=0x%x l2=0x%x,DataInputStream\n", l1,l2);
 
        long ln1 = bytesToLong(md5,0, false);
        long ln2 = bytesToLong(md5,8, false);
        System.out.printf("ln1=0x%x ln2=0x%x,ByteBuffer\n", ln1,ln2);
 
        long ll1 = longFrom8Bytes(md5,0, false);
        long ll2 = longFrom8Bytes(md5,8, false);    
        System.out.printf("ll1=0x%x ll2=0x%x\n", ll1,ll2);
    }
}

输出结果 md5 [39627933ceeebf2740e1f822921f5837] l1=0x39627933ceeebf27 l2=0x40e1f822921f5837,DataInputStream ln1=0x39627933ceeebf27 ln2=0x40e1f822921f5837,,ByteBuffer ll1=0x39627933ceeebf27 ll2=0x40e1f822921f5837 参考资料 《Java 中 byte、byte 数组和 int、long 之间的转换》   from:https://blog.csdn.net/10km/article/details/77435659

龙生   23 Nov 2019
View Details

Java中四种线程安全的单例模式实现方式

第一种：饿汉模式（线程安全）

1
2
3
4
5
6
7
8
9
10
11
12
public class Single2 {
 
    private static Single2 instance = new Single2();
    
    private Single2(){
        System.out.println("Single2: " + System.nanoTime());
    }
    
    public static Single2 getInstance(){
        return instance;
    }
}

  第二种：懒汉模式 （如果方法没有synchronized，则线程不安全）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class Single3 {
 
    private static Single3 instance = null;
    
    private Single3(){
        System.out.println("Single3: " + System.nanoTime());
    }
    
    public static synchronized Single3 getInstance(){
        if(instance == null){
            instance = new Single3();
        }
        return instance;
    }
}

  第三种：懒汉模式改良版（线程安全，使用了double-check，即check-加锁-check，目的是为了减少同步的开销）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public class Single4 {
 
    private volatile static Single4 instance = null;
    
    private Single4(){
        System.out.println("Single4: " + System.nanoTime());
    }
    
    public static Single4 getInstance(){
        if(instance == null){
            synchronized (Single4.class) {
                if(instance == null){
                    instance = new Single4();
                }
            }
        }
        return instance;
    }
}

  第四种：利用私有的内部工厂类（线程安全，内部类也可以换成内部接口，不过工厂类变量的作用域要改为public了。）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class Singleton {
    
    private Singleton(){
        System.out.println("Singleton: " + System.nanoTime());
    }
    
    public static Singleton getInstance(){
        return SingletonFactory.singletonInstance;
    }
    
    private static class SingletonFactory{
        private static Singleton singletonInstance = new Singleton();
    }
}

  from:https://my.oschina.net/yangchunlian/blog/1607947

龙生   23 Nov 2019
View Details

用 wait-notify 写一段代码来解决生产者-消费者问题

在同步块中调用 wait() 和 notify()方法，如果阻塞，通过循环来测试等待条件。请参考答案中的示例代码。 【生产者】

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
import java.util.Vector;
import java.util.logging.Level;
import java.util.logging.Logger;
 
public class Producer implements Runnable {
 
    private final Vector sharedQueue;
    private final int SIZE;
 
    public Producer(Vector sharedQueue, int size) {
        this.sharedQueue = sharedQueue;
        this.SIZE = size;
    }
 
    @Override
    public void run() {
        // 生产数据
        for (int i = 0; i < 7; i++) {
            System.out.println("Produced:" + i);
            try {
                produce(i);
            } catch (InterruptedException ex) {
                Logger.getLogger(Producer.class.getName()).log(Level.SEVERE, null, ex);
            }
        }
    }
 
    private void produce(int i) throws InterruptedException {
 
        // wait if queue is full
        while (sharedQueue.size() == SIZE) {
            synchronized (sharedQueue) {
                System.out.println("Queue is full " + Thread.currentThread().getName()
                        + " is waiting , size: " + sharedQueue.size());
                sharedQueue.wait();
            }
        }
 
        // producing element and notify consumers
        synchronized (sharedQueue) {
            sharedQueue.add(i);
            sharedQueue.notifyAll();
        }
    }
}

【消费者】

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
import java.util.Vector;
import java.util.logging.Level;
import java.util.logging.Logger;
 
public class Consumer implements Runnable {
 
    private final Vector sharedQueue;
    private final int SIZE;
 
    public Consumer(Vector sharedQueue, int size) {
        this.sharedQueue = sharedQueue;
        this.SIZE = size;
    }
 
    @Override
    public void run() {
        // 消费数据
        while (true) {
            try {
                System.out.println("Consumer: " + consume());
                Thread.sleep(50);
            } catch (InterruptedException ex) {
                Logger.getLogger(Consumer.class.getName()).log(Level.SEVERE, null, ex);
            }
        }
    }
 
    private int consume() throws InterruptedException {
 
        // wait if queue is empty
        while (sharedQueue.isEmpty()) {
            synchronized (sharedQueue) {
                System.out.println("Queue is empty " + Thread.currentThread().getName()
                        + " is waiting , size: " + sharedQueue.size());
                sharedQueue.wait();
            }
        }
 
        //otherwise consume element and notify waiting producer
        synchronized (sharedQueue) {
            sharedQueue.notifyAll();
            return (Integer) sharedQueue.remove(0);
        }
    }
}

【测试函数】

1
2
3
4
5
6
7
8
9
10
11
12
13
import java.util.Vector;
 
public class ProducerConsumerSolution {
 
    public static void main(String[] args) {
        Vector sharedQueue = new Vector();
        int size = 4;
        Thread prodThread = new Thread(new Producer(sharedQueue, size), "Producer");
        Thread consThread = new Thread(new Consumer(sharedQueue, size), "Consumer");
        prodThread.start();
        consThread.start();
    }
}

  运行结果：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
Produced:0
Queue is empty Consumer is waiting , size: 0
Produced:1
Consumer: 0
Produced:2
Produced:3
Produced:4
Produced:5
Queue is full Producer is waiting , size: 4
Consumer: 1
Produced:6
Queue is full Producer is waiting , size: 4
Consumer: 2
Consumer: 3
Consumer: 4
Consumer: 5
Consumer: 6
Queue is empty Consumer is waiting , size: 0

  from:https://www.cnblogs.com/xbq8080/p/10371214.html

龙生   23 Nov 2019
View Details

maven install时报错Failed to execute goal org.apache.maven.plugins:maven-surefire-plugin:2.12.4:test

事故现场： 解决办法： 一是命令行，

1
mvn clean package -Dmaven.test.skip=true

二是写入pom文件

1
2
3
4
5
6
7
8
<plugin>  
        <groupId>org.apache.maven.plugins</groupId>  
        <artifactId>maven-surefire-plugin</artifactId>  
        <version>2.4.2</version>  
        <configuration>  
          <skipTests>true</skipTests>  
        </configuration>  
</plugin>

  from:https://www.cnblogs.com/lxcy/p/8279899.html

龙生   20 Nov 2019
View Details

师说开源CMS 在IDEA 下运行起来的方法

1.git 项目到仓库中。 2.运行maven 导入JAR包 3.配置项目project structure（CTRL+ALT+SHIFT+S） project settings 第一项 Project compiler output 路径 : D:\git\CMS\target\shishuocms-2.0.1\WEB-INF\classes 第二项 Modules: Paths 选择第一个 Inherit project compile output path 复制 applicationContext.xml 、 log4j.properties、 shishuocms.properties 到 target/shishuocms-2.0.1/WEB-INF/classes下面。 别忘了修改shishuocms.properties的数据库连接配置。 ———————————————— 版权声明：本文为CSDN博主「matt0614」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。 原文链接：https://blog.csdn.net/matt0614/article/details/44972539

龙生   19 Nov 2019
View Details

CD基金会、Jenkins、Jenkins X、Spinnaker和Tekton的常问问题

FAQ 什么是持续交付（CD）？ CD是一种软件工程方法，团队在短周期内生成软件，确保软件可以随时可靠地发布。微服务、云原生架构的兴起引发了持续交付实践的必然结果。这与CI/CD有关，其中包括持续集成（CI） – 将所有开发者工作副本一天多次合并到共享主线的做法。 宣布了什么？ CDF（Continuous Delivery Foundation，持续交付基金会）是一个新的、中立的组织，将发展和维持一个开放的持续交付生态系统。它将提供统一的治理和与供应商中立的管理，以及对资金和运营的监督。CD基金会的第一批项目是Jenkins、Jenkins X、Spinnaker和Tekton。 为什么CD社区组成基金会。为什么需要？ 整个行业都迫切需要围绕管道、工作流程和其他CI/CD领域合作定义行业规范，并为CI/CD工具提供基础支持。例如，Jenkins社区正在寻求一个“全方位服务”的基金会来托管Jenkins（最受欢迎的CI/CD项目之一），并构建一个增强协作的平台。还需要一个全行业的中立DevOps/CD会议。 这是否代表了云原生态系统的转变？ 是的，市场已转向容器化和云原生技术，因此CI/CD系统、DevOps和相关工具的生态系统发生了根本性的变化。CNCF云原生互动景观展示了CI/CD领域的多样性，以及在该领域中活跃的众多项目和供应商。 通过建立供应商中立的持续交付基金会，业界顶级开发者、最终用户和供应商可以将CI/CD作为方法，定义/记录最佳实践以及创建培训材料，以使全球任何软件开发团队能够交付代码更改更快、更可靠、无论它们是否为云原生。 开发者为何要关心？ CI/CD项目目前面临的挑战，包括工具复杂性和管道和其他CI/CD工具缺乏行业标准化，正在抑制增长和创新。由于缺乏中立的法律实体和强有力的治理，项目很难吸引新开发者和组织的宝贵支持。项目维护者和开发者花费大量时间和金钱处理安全程序和监督等方面的变通方法。这使人们不再关注新的发展和创新。拥有广泛行业支持的基金会将能够更快地定义行业规范，并为跨项目协作创造更多机会，以改善开发者的工具。 谁用CD？ CD广泛应用于云计算、企业IT，并且正在迅速扩展到其他顶级行业垂直领域。例如，在网络运营商与供应商并肩工作，开发CI/CD工具，使开发者能够直接与上游项目的分支合作 – 大幅缩短实施新功能的时间，并解决数月到数天的错误。使用云原生技术（如Kubernetes）时，设置CI/CD管道将加快发布生命周期。这使开发者每天可以多次发布；让团队灵活到足以快速迭代。 CDF如何与渐进式交付相关？ 渐进式交付（Progressive delivery）是现代持续交付技术的一种形式，例如灰度发布、功能标记、A/B测试、经过验证的部署组等。渐进式交付技术和技术与持续交付密切相关。有关渐进式交付的更多信息，请阅读James Governor关于此主题的Redmonk博客：https://redmonk.com/jgovernor… 这将如何影响开源软件的开发？ 持续交付可提高软件开发团队的速度、生产力和可持续性。CDF促进行业顶级开发者、最终用户和供应商之间的合作，以确保CD方法的软件工程充分发挥其潜力，推进开源软件开发。 哪些项目将包含在CDF中？ CDF正在推出四个项目：Jenkins、Jenkins X、Spinnaker和Tekton，还有更多感兴趣的项目正在筹备中。我们邀请人们关注CDF技术监督委员会（“TOC”），该委员会将在未来做出项目决策：https://github.com/cdfoundati…。 我是否必须是成员才可以贡献到CDF项目？ 绝对不是，CDF中的开源项目或任何Linux基金会计划的技术贡献都不需要成员资格。组织作为成员加入CDF，因为它们希望在持续交付模型和最佳实践的增长和发展中扮演积极的角色，而不只是支持CDF中的开放源码项目。如果你有兴趣加入，请参阅https://cd.foundation/members…。 什么是Jenkins？ Jenkins是领先的开源自动化服务器，由大量不断增长的开发者、测试者、设计者和其他对持续集成、持续交付和现代软件交付实践感兴趣的人提供支持。它基于Java虚拟机（JVM），提供超过1,500个插件，可将Jenkins扩展为几乎所有技术软件交付团队使用的自动化服务器。2019年，Jenkins有超过了200,000个已知安装，使其成为部署最广泛的自动化服务器。 什么是Jenkins X？ Jenkins X是Kubernetes上现代云应用程序的开源CI/CD解决方案。Jenkins X提供管道自动化、内置GitOps和预览环境，以帮助团队协作并加速他们的软件交付。Jenkins X使用最好的OSS工具自动化Kubernetes的CI + CD，如Jenkins、Tekton、Prow、SkaffoldKaniko和Helm。 为什么Jenkins和Jenkins X成为CDF的一员？ Jenkins和Jenkins X将成为与技术兴趣相关的中立社区的一部分，并在构建开发者社区和项目治理方面获得帮助。CD基金会还将协助Jenkins和Jenkins X的营销和文档工作。 这对现有Jenkins用户有何影响？ 将Jenkins和Jenkins X捐赠给CD基金会将促进行业内开发者、最终用户和供应商之间的更多合作。有关详细信息，请参阅此电子邮件和与Jenkins社区的对话：https://groups.google.com/for… 什么是Tekton？ Tekton是一组用于构建CI/CD系统的共享开源组件。它使持续交付控制平面现代化，并将软件部署的大脑转移到Kubernetes。Tekton的目标是通过供应商中立的开源基金会为CI/CD管道、工作流程和其他构建模块提供行业规范。Tekton的代码在https://github.com/tektoncd/p…。 为什么Tekton成为CDF的一员？为什么Google会捐赠代码？ 作为CDF的创始成员，谷歌正在捐赠Tekton。正如Kubernetes通过提供一组标准的API在云中进行交互而彻底改变了应用程序开发，Google的目标是通过CD基金会为DevOps从业者提供相同的优势。CDF将提供行业规范、安全、实用和可扩展的持续交付构建块，可用于在任何地方部署代码。 Tekton对knative build的影响是什么？ 从第1天开始，可插拔性一直是knative的核心功能。将Build与Serving分离的目标是强化这种可插拔性概念。已经对构建系统感到满意的用户可以将其与Knative Serving一起使用。Tekton将继续支持Knative生态系统作为一流的目标环境。Tekton管道将部署到Knative环境。 在可预见的未来，Knative Build将继续作为Knative的一部分，专注于无服务器环境的源到容器工作流程。这两个项目将在标准和界面上保持紧密联系。 什么是Spinnaker？ Spinnaker是云端优先的持续交付平台，最初由Netflix创建，目前由Netflix和Google共同领导。它支持所有主要的云平台和Kubernetes，并得到各个供应商的贡献。Spinnaker通常用于大规模组织，DevOps团队通过提供“黄金路径”（golden path）应用程序部署管道来支持许多开发者。 为什么Google/Netflix将Spinnaker捐赠给CDF？ 随着Spinnaker最近将其治理正式化，将其转移到基金会是社区自然的下一步。Spinnaker设计为持续交付平台，通常与Jenkins结合使用，因此CDF真的是项目的理想之家。 Spinnaker也是一个多组件系统，在概念上与Tekton分享了许多想法 – 看到两个项目在一个基金会上聚集在一起，是将持续交付向前推进的巨大机会。 这对Spinnaker用户有何影响？ Spinnaker作为CDF的一员，社区将有更多机会创建更简单、更强大的端到端体验，并就CI/CD的一套通用标准进行协作。Spinnaker用户在持续交付领域拥有丰富的经验，加入CDF提供了一个与更广泛的社区分享专业知识的绝佳机会。 Spinnaker用户还将受益于CDF社区中广泛的CI/CD知识，他们使用的各种工具之间的一致性，当然还有不断改进的生态系统！ 未来的CI/CD项目进入CDF的过程是怎样？ 其他项目预计将通过其即将成立的技术监督委员会（TOC）加入CDF：https://github.com/cdfoundati…，重点是将CD生态系统整合在一起，围绕可移植性和互操作性构建规范和项目。 CDF的下一步是什么？ 接下来的步骤是启动治理结构。将成立一个理事会、技术和外联/营销委员会。我们计划在未来几个月内实现这一目标，并邀请新成员加入我们的社区。如果你有兴趣加入社区推进CD，请到https://cd.foundation/members…。 CNCF的参与程度，为什么需要一个单独的基金会？ 首先要注意的是，CD适用于整个软件行业，而不仅仅适用于现代云原生应用程序。CNCF（Cloud Native Computing Foundation，云计算本地计算基金会）是CDF的姐妹基金会，拥有自己的治理结构和使命。每个基金会都有不同的使命，由其创始成员和技术专家定义。CNCF认为大多数与CD相关的工具超出了他们专注的云原生定义的范围，后者主要关注容器化、微服务、服务网格和编排。CDF超越云和容器，包括传统基础设施、移动、物联网、裸机等。CNCF和CDF都属于较大的Linux基金会旗下，计划在许多领域进行合作，包括同场会议。例如，CDF将于5月20日在西班牙巴塞罗那的KubeCon + CloudNativeCon Europe 2019举办持续交付峰会（CDS）活动。 CDF如何支持或与DevOps领域的其他玩家合作？ CDF的使命是为开发者、最终用户和供应商提供一个中立的家庭，以便在CI/CD方法上进行协作。在这方面，CDF将通过发布关注可移植性的最佳实践、培训材料和行业指南来支持DevOps从业者。 有兴趣成为这个新基金会成员并制定治理方案的组织应到CDF加入的页面。开发者可以在此处注册CD基金会邮件列表：info@lists.cd.foundation。任何有兴趣加入CDF的项目都可以联系技术监督委员会（TOC）：https://github.com/cdfoundati…。 KubeCon […]

龙生   12 Nov 2019
View Details
1 … 41 42 43 … 64

Copyright © 2025 Longsheng All rights reserved