public class LocalUser implements User {
    private String name;
    private String mspId;
    private Enrollment enrollment;

    LocalUser(String name, String mspId, String keyFile, String certFile) throws Exception {
        this.name = name;
        this.mspId = mspId;
        this.enrollment = loadFromPemFile(keyFile, certFile);
    }

    private Enrollment loadFromPemFile(String keyFile, String certFile) throws Exception {
        byte[] keyPem = Files.readAllBytes(Paths.get(keyFile));
        byte[] certPem = Files.readAllBytes(Paths.get(certFile));
        CryptoPrimitives suite = new CryptoPrimitives();
        PrivateKey privateKey = suite.bytesToPrivateKey(keyPem);
        return new X509Enrollment(privateKey, new String(certPem));
    }

    @Override
    public String getName() {
        return name;
    }

    public Set<String> getRoles() {
        return null;
    }

    public String getMspId() {
        return mspId;
    }

    @Override
    public Enrollment getEnrollment() {
        return enrollment;
    }

    @Override
    public String getAccount() {
        return null;
    }

    @Override
    public String getAffiliation() {
        return null;
    }

}

public class FabricTest {

    private static final String BASE_PATH = "./fabric";
    private static final String CHANNEL_NAME = "CHANNEL_NAME";
    private static final String CHAINCODE_ID = "CHAINCODE_ID";
    private static final Map<String, String> ORDERER_MAP = new HashMap<>();
    private static final Map<String, String> PEER_MAP = new HashMap<>();
    private static final boolean TLS = true;

    static
        String protocol = "grpc";
        if(TLS) {
            protocol += "s";
        }
        ORDERER_MAP.put("test.com", protocol + "://127.0.0.1:7050");
        PEER_MAP.put("peer.test.com", protocol + "://127.0.0.1:7051");
    }

    public static void main(String[] args) throws Exception {
        String keyFile = BASE_PATH + "***/user-key.pem";
        String certFile = BASE_PATH + "***/user-cert.pem";
        LocalUser user = new LocalUser("username", "mspId", keyFile, certFile);

        HFClient client = HFClient.createNewInstance();
        client.setCryptoSuite(CryptoSuite.Factory.getCryptoSuite());
        client.setUserContext(user);

        Channel channel = client.newChannel(CHANNEL_NAME);
        for (Map.Entry<String, String> entry : ORDERER_MAP.entrySet()) {
            Properties properties = new Properties();
            if(TLS) {
                properties.setProperty("clientCertFile", "对应配置目录下users/***/tls/client.crt文件");
                properties.setProperty("clientKeyFile", "对应配置目录下users/***/tls/client.key文件");
                properties.setProperty("pemFile", "对应配置目录下/tls/server.crt文件");
                properties.setProperty("hostnameOverride", entry.getKey());
                properties.setProperty("sslProvider", "openSSL");
                properties.setProperty("negotiationType", "TLS");
            }
            channel.addOrderer(client.newOrderer(entry.getKey(), entry.getValue(), properties));
        }
        for (Map.Entry<String, String> entry : PEER_MAP.entrySet()) {
            Properties properties = new Properties();
            if(TLS) {
                properties.setProperty("clientCertFile", "对应配置目录下users/***/tls/client.crt文件");
                properties.setProperty("clientKeyFile", "对应配置目录下users/***/tls/client.key文件");
                properties.setProperty("pemFile", "对应配置目录下/tls/server.crt文件");
                properties.setProperty("hostnameOverride", entry.getKey());
                properties.setProperty("sslProvider", "openSSL");
                properties.setProperty("negotiationType", "TLS");
            }
            channel.addPeer(client.newPeer(entry.getKey(), entry.getValue(), properties));
        }
        channel.initialize();

        System.out.format("Valid: %s\n", invokeRequest(client, channel, "insert", "ID1","VALUE222"));
        System.out.format("Message: %s\n", queryRequest(client, channel, "query", "ID1"));
    }

    private static String queryRequest(HFClient client, Channel channel, String function, String... args) throws Exception {
        QueryByChaincodeRequest request = client.newQueryProposalRequest();
        request.setChaincodeName(CHAINCODE_ID);
        request.setFcn(function);
        request.setArgs(args);
        ProposalResponse[] responses = channel.queryByChaincode(request).toArray(new ProposalResponse[0]);
        return responses[0].getProposalResponse().getResponse().getPayload().toStringUtf8();
    }

    private static boolean invokeRequest(HFClient client, Channel channel, String function, String... args) throws Exception {
        TransactionProposalRequest request = client.newTransactionProposalRequest();
        request.setChaincodeName(CHAINCODE_ID);
        request.setFcn(function);
        request.setArgs(args);
        Collection<ProposalResponse> responses = channel.sendTransactionProposal(request);
        BlockEvent.TransactionEvent event = channel.sendTransaction(responses).get();
        return event.isValid();
    }
}

import java.util.concurrent.Semaphore;

public class Generator {

    private Function function;

    private Runnable runnable;
    private Thread thread;

    private Semaphore readLock;
    private Semaphore writeLock;

    private Result result;
    private Object nextValue;
    private boolean done = true;

    public Generator(Function function) {
        this.function = function;
        this.runnable = () -> {
            try {
                this.writeLock.acquire();
                Object value = this.function.run(this);
                this.result = new Result(value, true);
                this.readLock.release();
            } catch (Exception e) {
                e.printStackTrace();
            }
        };
        this.reset();
    }

    public boolean isDone() {
        return done;
    }

    public synchronized void reset() {
        this.close();
        this.readLock = new Semaphore(0);
        this.writeLock = new Semaphore(0);
        this.result = null;
        this.nextValue = null;
        this.done = false;
        this.thread = new Thread(this.runnable);
        this.thread.start();
    }

    public synchronized void close() {
        if (this.thread != null) {
            this.thread.stop();
            this.thread = null;
        }
    }

    public synchronized Result next() throws InterruptedException {
        return this.next(null);
    }

    public synchronized Result next(Object value) throws InterruptedException {
        if (this.done) {
            return null;
        }
        this.nextValue = value;
        this.writeLock.release();
        this.readLock.acquire();
        Result result = this.result;
        this.done = result.isDone();
        return result;
    }

    public Object yield(Object value) throws InterruptedException {
        this.result = new Result(value, false);
        this.readLock.release();
        this.writeLock.acquire();
        return this.nextValue;
    }

    @FunctionalInterface
    public interface Function {
        Object run(Generator context) throws Exception;
    }

    public static class Result {
        private Object value;
        private boolean done;

        private Result(Object value, boolean done) {
            this.value = value;
            this.done = done;
        }

        public Object getValue() {
            return value;
        }

        public boolean isDone() {
            return done;
        }

        @Override
        public String toString() {
            return "Result{" +
                    "value=" + value +
                    ", done=" + done +
                    '}';
        }
    }
}

public class Main {

    public static void main(String[] args) throws InterruptedException {
        Generator generator = new Generator(context -> {
            int count = 0;
            for (int i = 0; i < 10; i++) {
                Integer value = (Integer) context.yield(i);
                count += value == null ? 0 : value;
            }
            return count;
        });

        Generator.Result result = null;
        do {
            result = generator.next(result == null ? null : result.getValue());
            System.out.println(result);
        } while (!result.isDone());
    }
}

/* 输出结果
Result{value=0, done=false}
Result{value=1, done=false}
Result{value=2, done=false}
Result{value=3, done=false}
Result{value=4, done=false}
Result{value=5, done=false}
Result{value=6, done=false}
Result{value=7, done=false}
Result{value=8, done=false}
Result{value=9, done=false}
Result{value=45, done=true}
*/

import javax.crypto.Cipher;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;
import java.util.Base64;
import java.util.UUID;

public class AesUtils {

    private static final String TYPE = "AES";
    private static final String ALGORITHM = "AES/CBC/PKCS5Padding";
    private static final String CHARSET = "UTF-8";

    public static String createKey(){
        return UUID.randomUUID().toString().replace("-","").substring(16);
    }

    public static String encrypt(String data, String key) throws Exception {
        IvParameterSpec ivParameterSpec = new IvParameterSpec(key.getBytes());
        SecretKeySpec keySpec = new SecretKeySpec(key.getBytes(), TYPE);
        Cipher cipher = Cipher.getInstance(ALGORITHM);
        cipher.init(Cipher.ENCRYPT_MODE, keySpec, ivParameterSpec);
        return Base64.getEncoder().encodeToString(cipher.doFinal(data.getBytes(CHARSET)));
    }

    public static String decrypt(String data, String key) throws Exception {
        IvParameterSpec ivParameterSpec = new IvParameterSpec(key.getBytes());
        SecretKeySpec keySpec = new SecretKeySpec(key.getBytes(), TYPE);
        Cipher cipher = Cipher.getInstance(ALGORITHM);
        cipher.init(Cipher.DECRYPT_MODE, keySpec, ivParameterSpec);
        return new String(cipher.doFinal(Base64.getDecoder().decode(data.getBytes())), CHARSET);
    }
}

import javax.crypto.Cipher;
import java.io.ByteArrayOutputStream;
import java.security.KeyFactory;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.Base64;

public class RsaUtils {

    private static final String TYPE = "RSA";
    private static final String ALGORITHM = "RSA/ECB/PKCS1PADDING";
    private static final String CHARSET = "UTF-8";
    private static final int KEY_SIZE = 1024;

    public static KeyPair createKeyPair() {
        try {
            KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(TYPE);
            keyPairGenerator.initialize(KEY_SIZE);
            return keyPairGenerator.generateKeyPair();
        } catch (Exception e) {
            return null;
        }
    }

    public static String getPublicKey(KeyPair keyPair) {
        return Base64.getEncoder().encodeToString(keyPair.getPublic().getEncoded());
    }

    public static String getPrivateKey(KeyPair keyPair) {
        return Base64.getEncoder().encodeToString(keyPair.getPrivate().getEncoded());
    }

    public static String encrypt(String data, String publicKeyString) throws Exception {
        Cipher cipher = Cipher.getInstance(ALGORITHM);
        KeyFactory keyFactory = KeyFactory.getInstance(TYPE);
        X509EncodedKeySpec keySpec = new X509EncodedKeySpec(Base64.getDecoder().decode(publicKeyString));
        RSAPublicKey publicKey = (RSAPublicKey) keyFactory.generatePublic(keySpec);
        cipher.init(Cipher.ENCRYPT_MODE, publicKey);
        return Base64.getEncoder().encodeToString(splitCodec(cipher, Cipher.ENCRYPT_MODE, data.getBytes(CHARSET)));
    }

    public static String decrypt(String data, String privateKeyString) throws Exception {
        Cipher cipher = Cipher.getInstance(ALGORITHM);
        KeyFactory keyFactory = KeyFactory.getInstance(TYPE);
        PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(Base64.getDecoder().decode(privateKeyString));
        RSAPrivateKey privateKey = (RSAPrivateKey) keyFactory.generatePrivate(keySpec);
        cipher.init(Cipher.DECRYPT_MODE, privateKey);
        return new String(splitCodec(cipher, Cipher.DECRYPT_MODE, Base64.getDecoder().decode(data)), CHARSET);
    }

    private static byte[] splitCodec(Cipher cipher, int mode, byte[] data) throws Exception {
        int maxBlock = KEY_SIZE / 8 - (mode == Cipher.DECRYPT_MODE ? 0 : 11);
        try (ByteArrayOutputStream out = new ByteArrayOutputStream()) {
            byte[] buffer;
            for (int offset = 0; offset < data.length; offset += maxBlock) {
                buffer = cipher.doFinal(data, offset, Math.min(maxBlock, data.length - offset));
                out.write(buffer, 0, buffer.length);
            }
            return out.toByteArray();
        }
    }
}

public interface DODao<T extends DO> extends Dao<T> {

    @SelectProvider(type = SqlProvider.class, method = "selectById")
    T selectById(Long id);

    @InsertProvider(type = SqlProvider.class, method = "insert")
    @Options(useGeneratedKeys = true, keyColumn = "id")
    int insert(T bean);

    @UpdateProvider(type = SqlProvider.class, method = "update")
    int update(T bean);

    @DeleteProvider(type = SqlProvider.class, method = "delete")
    int delete(Long id);
}

public String selectById(ProviderContext context) {
    Class clazz = getEntityClass(context);
    assert clazz != null;
    return new SQL()
            .SELECT(getColumns(clazz))
            .FROM(getTableName(clazz))
            .WHERE("`id`=#{id}")
            .toString();
}

private Class getEntityClass(ProviderContext context) {
    for (Type type : context.getMapperType().getGenericInterfaces()) {
        ResolvableType resolvableType = ResolvableType.forType(type);
        if (resolvableType.getRawClass() == Dao.class
                || resolvableType.getRawClass() == DODao.class
                || resolvableType.getRawClass() == VODao.class) {
            return resolvableType.getGeneric(0).getRawClass();
        }
    }
    return null;
}

private String[] getVariables(Class clazz, String[] prefixes) {
    List<String> variables = new ArrayList<>();
    for (Method method : clazz.getMethods()) {
        Ignore annotation = method.getAnnotation(Ignore.class);
        if (annotation != null) {
            continue;
        }
        String name = method.getName();
        for (String prefix : prefixes) {
            int length = prefix.length();
            if (name.length() > length && name.startsWith(prefix)
                    && name.charAt(length) >= 'A' && name.charAt(length) <= 'Z') {
                String variableName = (char) (name.charAt(length) - 'A' + 'a') + name.substring(length + 1);
                variables.add(variableName);
                break;
            }
        }

    }
    return variables.toArray(new String[]{});
}

private String[] getReadVariables(Class clazz) {
    return getVariables(clazz, new String[]{"is", "get"});
}

public interface TestService {
    String print(String s);
}

import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.net.InetSocketAddress;
import java.net.Socket;

public class Consumer {
    
    public static void main(String[] as) {

        TestService service = (TestService) Proxy.newProxyInstance(TestService.class.getClassLoader(), new Class<?>[]{TestService.class}, (Object proxy, Method method, Object[] args) -> {
            try(Socket socket = new Socket()){
                socket.connect(new InetSocketAddress(12306));
                ObjectOutputStream os = new ObjectOutputStream(socket.getOutputStream());
                os.writeUTF(method.getName());
                os.writeObject(method.getParameterTypes());
                os.writeObject(args);
                return new ObjectInputStream(socket.getInputStream()).readObject();
            }catch (Exception e){
                return null;
            }
        });
        System.out.println(service.print("abc"));
    }
}

import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.net.InetSocketAddress;
import java.net.ServerSocket;
import java.net.Socket;

public class Producer {

    public static void main(String[] args)  {

        TestService service = new TestServiceImpl();

        try (ServerSocket serverSocket = new ServerSocket()){
            serverSocket.bind(new InetSocketAddress(12306));

            try(Socket accept = serverSocket.accept()){
                ObjectInputStream is = new ObjectInputStream(accept.getInputStream());
                String methodName = is.readUTF();
                Class<?>[] parameterTypes = (Class<?>[]) is.readObject();
                Object[] arguments = (Object[]) is.readObject();
                Object result = TestService.class.getMethod(methodName,parameterTypes).invoke(service,arguments);
                new ObjectOutputStream(accept.getOutputStream()).writeObject(result);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }

    }
}

public class TestServiceImpl implements TestService{

    @Override
    public String print(String s) {
        return "**"+s+"**";
    }
}

System.out.println(service.print("abc"));