JAVA日记

枚举类

package com.inspur.gs.lsvo.fcoe.zd.base.mailset.Enum;


public enum SYSIType {
    /* 枚举对象必须放在枚举类的行首 缩写的构造函数**/
    /* 账户对账 **/
    ZHDZ("0"),
    /* 活期协定 **/
    hqfhz("1"),
    /* 定期通知分户账 **/
    dqfhz("2"),
    /* 委托贷款 **/
    wdfhz("3"),
    /* 特殊业务 **/
    tsfhz("4");
    private String value;
    /* 将构造器私有化,为了防止直接 new **/
    private SYSIType(String value){
        this.value =value;
    }
    //去掉 setXxx 方法, 防止属性被修改，只保留getXxx方法，用于读取
    public String getValue(){
        return value;
    }
}

判断list.size()>0

dsXNKM.isEmpty() //dsXNKM --是List

邮箱email

以下是对应的Java代码：

//定义变量
String GUIDstring = "";
String v_pcVNUMBER = "";
StringBuilder stringBuilder = new StringBuilder();

//构造SQL语句
String existssql = "SELECT NVL(MAX(ZJZDFILE_ISSTORE),'-1') FROM ZJZDFILE WHERE ZJZDFILE_NAME = '" + Path.getFileName(item) + "'";
//执行查询，获取结果
try (Connection conn = DriverManager.getConnection(DesStringHelper.DbCodeName);
     PreparedStatement stmt = conn.prepareStatement(existssql)) {
    ResultSet rs = stmt.executeQuery();
    if (rs.next()) {
        stringBuilder.append(rs.getString(1));
    }
} catch (SQLException e) {
    e.printStackTrace();
}

//构造SQL语句
existssql = "SELECT ZJZDFILE_ISSTORE,ZJZDFILE_NM FROM ZJZDFILE WHERE ZJZDFILE_NAME = '" + Path.getFileName(item) + "' ORDER BY ZJZDFILE.Createddate DESC";
//执行查询，获取结果
try (Connection conn = DriverManager.getConnection(DesStringHelper.DbCodeName);
     PreparedStatement stmt = conn.prepareStatement(existssql)) {
    ResultSet rs = stmt.executeQuery();
    if (rs.next()) {
        GUIDstring = rs.getString("ZJZDFILE_NM");
        stringBuilder.append(rs.getString("ZJZDFILE_ISSTORE"));
    }
} catch (SQLException e) {
    e.printStackTrace();
}

注意：以上代码仅提供参考，没有进行输入校验和异常处理等操作，实际应用中需要按照实际情况进行修改和完善。

FilenameUtils工具类

在Java中，你可以使用以下代码来实现与Path.GetFileNameWithoutExtension(item).Split('-')相同的功能：

String itemWithoutExtension = FilenameUtils.removeExtension(item);
String[] arrVs = itemWithoutExtension.split("-");

这里使用了Apache Commons IO库中的FilenameUtils.removeExtension()方法来获取没有扩展名的文件名。然后，使用String类的split()方法根据"-"字符将字符串分割成一个字符串数组。

确保在使用之前，你已经在项目中引入了Apache Commons IO库。

开发WebService项目基本步骤

1. 选择一个WebService框架：选择一个适合你的项目的WebService框架，例如Apache CXF、Axis2、Jersey等。
2. 配置环境：安装Java开发工具包（JDK）和配置Web服务器，例如Apache Tomcat。
3. 创建项目：使用你选择的WebService框架创建一个新的Web服务项目。
4. 创建WSDL文件：使用WSDL编写器创建WSDL文件，该文件描述了Web服务的接口和操作。
5. 实现服务：使用Java编写服务实现类，实现WSDL文件中定义的接口和操作。
6. 发布服务：将服务实现类发布到Web服务器上，使其能够被远程调用。
7. 测试服务：使用SOAP客户端测试Web服务，确保其正常工作。
8. 文档服务：创建文档，描述Web服务的接口和操作，以便其他开发人员可以了解和使用它。
   以上是WebService项目的基本开发步骤，具体实现细节可能因所选的框架而异。

Date类型增加一天

在Java中，你可以使用java.util.Calendar类来为日期（例如Date类型）增加一天。以下是一个简单的示例：

import java.util.Date;
import java.util.Calendar;

public class Main {
    public static void main(String[] args) {
        // 创建一个 Date 对象
        Date currentDate = new Date();
        System.out.println("当前日期: " + currentDate);

        // 创建一个 Calendar 对象，并将当前日期设置给它
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(currentDate);

        // 将日期增加一天
        calendar.add(Calendar.DATE, 1);

        // 获取增加一天后的日期
        currentDate = calendar.getTime();
        System.out.println("增加一天后的日期: " + currentDate);
    }
}

在上述代码中，Calendar.DATE是一个常量，代表日期。add方法会根据指定的常量类型增加其对应的值。因此，add(Calendar.DATE, 1)会增加日期一天。然后我们可以通过getTime()方法从Calendar对象获取增加一天后的新日期。

日期处理

idea 代码审查时出现问题的常见思路

Raw use of parameterized class ‘HashMap’ --> idea给的提示不是很合理时 可以注意new map<>() 或者 new HashMap<>() 可以通过加<>泛型符号

注：泛型作用 提高代码可重复性 在Java和C#等语言中，泛型已经得到了广泛的应用。这些语言中的泛型是通过类型参数化的方式实现的，允许在类、接口或方法定义中使用类型参数。通过这种方式，可以将一个类型参数化，从而可以用该类型的任何子类型来实例化泛型

泛型类 泛型方法

在Java中，可以在类和方法上定义泛型。

在类上定义泛型

在类上定义泛型的方式如下：

public class MyClass<T> {
    // ...
}

这里的 <T> 是一个类型参数，表示这是一个泛型类。类型参数 T 可以是任何类型，例如 Integer、String 或者其他任何类型。在类中可以使用 T 来定义变量、方法的返回类型等。

例如：

// 写的时候是带着滴
public class MyClass<T> {
    private T item;

    public T getItem() {
        return item;
    }

    public void setItem(T item) {
        this.item = item;
    }
}

在这个例子中，T 用于定义了一个私有成员变量 item 和其相关的 getter 和 setter 方法。

在方法上定义泛型

在方法上定义泛型的方式如下：

public <T> void myMethod(T item) {
    // ...
}

这里的 <T> 是一个类型参数，表示这是一个泛型方法。类型参数 T 可以是任何类型，例如 Integer、String 或者其他任何类型。在方法中可以使用 T 来定义方法的返回类型、形参等。

例如：

public class MyClass {
    // 写的时候<T>是不带滴
    public <T> void printItem(T item) {
        System.out.println(item.toString());
    }
}

在这个例子中，<T> 用于定义了一个泛型方法 printItem，这个方法接收一个 item 参数，并打印其字符串表示形式。这里的 T 可以是任何类型，例如 Integer、String 或者其他任何类型。

oracle insert语句 重复数据判断

是的，通过使用NOT EXISTS条件，你可以在插入数据之前检查是否已经存在相同的数据。如果不存在相同的数据，则执行插入操作，否则，插入操作将被忽略。
下面是一个示例，演示如何使用NOT EXISTS条件来执行插入操作：

INSERT INTO table_name (column1, column2)
SELECT :value1, :value2 FROM dual
WHERE NOT EXISTS (SELECT 1 FROM table_name WHERE column1 = :value1 AND column2 = :value2);

在上面的示例中，table_name是目标表的名称，column1和column2是要插入数据的列名，:value1和:value2是要插入的值。通过使用NOT EXISTS条件，你可以检查是否已经存在与:value1和:value2相同的数据。如果不存在相同的数据，则执行插入操作。

请注意，这种方法适用于在插入数据之前进行重复检查，并且只能用于单条插入语句。如果你需要批量插入数据并避免重复，可能需要使用其他方法，如使用唯一约束或主键约束。

自动注入(@注解 – 代替了new的过程 可以直接调用属性及方法 但是你得让spring知道你"new"的哪个类)和手动new 的区别

字节输入流和字符输入流适用场景

在Java中，字节流和字符流各有其优点和适用场景，具体使用哪种取决于你要处理的数据类型和需求。

一般来说，字节流更适合处理二进制数据，如图片、视频、音频等，或者用于在网络中传输数据。因为这些数据在传输时都是以字节的方式进行的。

字符流更适合处理文本数据，如字符串。在内存中，字符才会形成，因此字符流适合对内存中的字符串进行处理。

如果你需要读取或写入大量文本数据，并且这些数据已经在内存中以字符串的形式存在，那么使用字符流会更高效。

如果你要处理的是二进制数据或者图片、视频等，或者你要在网络中传输这些数据，那么使用字节流更好。

总之，选择使用字符流还是字节流主要取决于你要处理的数据类型和你想要实现的功能。

域名配置

涉及到的本地文件 C:\Windows\System32\drivers\etc\hosts

jdk 报错：源发行版 17 需要目标发行版 17

源发行版 pom.xml文件–项目中的jdk版本

目标发行版 java -version 安装的jdk版本 --settings中的版本

JSON格式(字符串)转换成指定对象

//用于将JSON字符串转化为Java对象
JSON.parseObject(MsgHeaderUtil.getMsgHaeder(), MSGHEADER.class)

这段代码是Java语言中的用法。JSON.parseObject是Java的Jackson库中的一个函数，用于将JSON字符串转化为Java对象。
在此处，MsgHeaderUtil.getMsgHaeder()可能返回一个JSON格式的字符串，而MSGHEADER.class表示一个Java类，这个类的结构应与JSON字符串中的数据相匹配。
所以，这段代码的作用是从MsgHeaderUtil.getMsgHaeder()返回的JSON字符串中解析出一个MSGHEADER类型的对象。这个对象在JSON字符串中的数据应与MSGHEADER类中的字段和属性相匹配。如果JSON字符串中的数据与MSGHEADER类不匹配，那么在解析过程中可能会抛出异常。

java中调用存储过程

try {
            MultiTenantConnectionProvider connectionProvider = (MultiTenantConnectionProvider) Class.forName(s1).newInstance();
            CurrentTenantIdentifierResolver identifierResolver = (CurrentTenantIdentifierResolver) Class.forName(s2).newInstance();
            String databaseId = identifierResolver.resolveCurrentTenantIdentifier();
            try (Connection conn = connectionProvider.getConnection(databaseId)) {
                CallableStatement callableStatement = conn.prepareCall("{ call Lsvo_Fcoe_zddz(?, ?, ?, ?, ?, ?, ?) }");
                callableStatement.setString(1, zhbh);
                callableStatement.setString(2, bz);
                callableStatement.setString(3, "");
                callableStatement.setString(4, "");
                callableStatement.setString(5, "");
                callableStatement.setString(6, "");
                callableStatement.setString(7, "");
                //callableStatement.registerOutParameter(7, Types.REF_CURSOR);
                callableStatement.execute();
                lsvoIdpResult.setCode("1");
            } catch (Exception e) {
                e.printStackTrace();
            }
        } catch (Exception ex) {
            log.error("自动对账出现异常：{} ", ex);
            lsvoIdpResult.setCode("-1");
        }

XMLGregorianCalendar转date

// XMLGregorianCalendar => GregorianCalendar => Date
inputcollectionitem.getAPPLYDATE().toGregorianCalendar().getTime()

Date 转 XMLGregorianCalendar

// DatatypeFactory => dataTypeFactory.newXMLGregorianCalendar(String date) => XMLGregorianCalendar
String date = String.valueOf(fcoeYspjsymxb.getShksr()).replace("-", "");
DatatypeFactory dataTypeFactory = DatatypeFactory.newInstance();
XMLGregorianCalendar calendar = dataTypeFactory.newXMLGregorianCalendar(date);

或者

// Date 转 XMLGregorianCalendar 
Date date = new Date();
GregorianCalendar cal = new GregorianCalendar();
cal.setTime(date);
XMLGregorianCalendar webserviceDate = DatatypeFactory.newInstance().newXMLGregorianCalendar(cal);

映射

 private <T> T generateEntity(Class<T> obj, Map<String, Object> mapInfo, Date date) {
        try {
            // 使用反射获取字段  这样写 仅仅只是因为 T泛型的原因 一般实例化以后 可以直接调方法
//        Field[] fields = obj.getDeclaredFields();
            // 设置创建和修改时间
            /* 获取到 一个 set 方法(特征：名字叫setCreatetime 且有一个参数 参数类型为Date )真正调用需要使用invoke **/
            Method setPriKey = obj.getMethod("setPriKey", String.class); // 类.getMethod(方法名,返回值)
            Method setApplication = obj.getMethod("setApplication", String.class);
            Method setCompanyCode =obj.getMethod("setCompanyCode", String.class);
            Method setPeriodName =obj.getMethod("setPeriodName", String.class);
            Method setStatusCode =obj.getMethod("setStatusCode", String.class);
            Method setStatusDetailedCode =obj.getMethod("setStatusDetailedCode", String.class);
            Method setInputExt =obj.getMethod("setInputExt", String.class);
            Method setCreatetimeMethod = obj.getMethod("setCreatetime", Date.class);
            Method setLastmodifytimeMethod = obj.getMethod("setLastmodifytime", Date.class);
            /* 获取到对应方法 **/
            T newObj = obj.newInstance();
            setPriKey.invoke(newObj, Convert.toStr(mapInfo.get("PRI_KEY"))); // 方法名.invoke(类名,参数)
            setApplication.invoke(newObj,Convert.toStr(mapInfo.get("APPLICATION")));
            setCompanyCode.invoke(newObj,Convert.toStr(mapInfo.get("COMPANY_CODE")));
            setPeriodName.invoke(newObj, Convert.toStr(mapInfo.get("PERIOD_NAME")) );
            setStatusCode.invoke(newObj,Convert.toStr(mapInfo.get("STATUS_CODE")));
            setStatusDetailedCode.invoke(newObj, Convert.toStr(mapInfo.get("STATUS_DETAILED_CODE")));
            setInputExt.invoke(newObj, Convert.toStr(mapInfo.get("INPUT_EXT")));
            setCreatetimeMethod.invoke(newObj, date);
            setLastmodifytimeMethod.invoke(newObj, date);
            return newObj;
        } catch (InstantiationException | IllegalAccessException | NoSuchMethodException | SecurityException |
                 IllegalArgumentException | InvocationTargetException e) {
            throw new RuntimeException(e);
        }

    }
// 可以整合为 obj.getMethod("setPriKey", String.class).invoke(newObj, Convert.toStr(mapInfo.get("PRI_KEY")))
// 个人理解 类名：T  类驱动：Class<T>

序列化 反序列化参考代码------常见

    /**
     * @return T
     * @Title: Deserialize
     * @Description: 反序列化 -- 封装为对象
     * @param: t
     * @param: xml
     */
    public <T> T Deserialize(Class<T> t, String xml) {
        T message = null;
        try {
            JAXBContext jaxbContext = JAXBContext.newInstance(t);
            Unmarshaller unmarshaller = jaxbContext.createUnmarshaller();
            StringReader reader = new StringReader(xml);

            message = (T) unmarshaller.unmarshal(reader);
        } catch (JAXBException e) {
            e.printStackTrace();
        }
        return message;
    }
    /**
     * @Title: Serializer
     * @Description:  序列化 --返回字符串
     * @param t
     * @param configObject
     * @return java.lang.String
     * @throws
     */
    public <T> String Serializer(Class<T> t,T configObject){
        try {
            JAXBContext jaxbContext = JAXBContext.newInstance(t);
            Marshaller marshaller = jaxbContext.createMarshaller();
            marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT,true);
            marshaller.setProperty(Marshaller.JAXB_ENCODING,"UTF-8");
            /* 是否省略xml头信息 **/
            marshaller.setProperty(Marshaller.JAXB_FRAGMENT,false);
            StringWriter writer = new StringWriter();
            marshaller.marshal(configObject,writer);
            String s = writer.toString();
            return  s;
        } catch (JAXBException e) {
            System.out.println(e.getMessage());
            e.printStackTrace();
        }
        return null;
    }

/* ps: 使用 org.dom4j.Document 生成xml文件 **/
sendMessage = "<CMS><eb><pub><TransCode></TransCode><CIS></CIS><BankCode></BankCode><ID></ID><TranDate></TranDate><TranTime></TranTime><fSeqno></fSeqno></pub><in><AreaCode></AreaCode><NetCode></NetCode><TellerNo></TellerNo><WorkDate></WorkDate><TranSerialNo></TranSerialNo><AcctNo></AcctNo><CurrencyType></CurrencyType><ComplementFlag></ComplementFlag><CustId></CustId><SignTime></SignTime><ReqReserved1></ReqReserved1><ReqReserved2></ReqReserved2><ReqReserved3></ReqReserved3><ReqReserved4></ReqReserved4></in></eb></CMS>";
Document reqDoc = DocumentHelper.parseText(sendMessage);

Bigdecimal

new BigDecimal(需转换值) 之间比较大小 不能使用equals 因为equals 当1.0 和1.00比较时 会出现不相等情况

new BigDecimal(excelResult.result.get(3)).compareTo(BigDecimal.ZERO)

java中特殊sql语法执行

Merge语句可以将一个表中的数据合并到另一个表中，在合并的同时可以根据条件进行插入、删除、更新等操作，功能非常强大。

MERGE INTO table_name(目标表) alias1
 
USING (table|view|sub_query)(源表) alias2
 
ON (join condition)
 
WHEN MATCHED THEN
 
     UPDATE table_name SET col1 = col_val1,col2 = col2_val
 
WHEN NOT MATCHED THEN
 
     INSERT (column_list) VALUES (column_values)

例子如下

// merge into 表a --目标表 using 表b --源表 on 条件 ... when matched then update --> insert
StringBuilder pzUpdateSql = new StringBuilder();
            pzUpdateSql.append(" merge into FCOEZFDZFL using ( "); // 往FCOEZFDZFL表插入满足条件的数据
            pzUpdateSql.append(" select ZHBH,JSFS,PZBH,PZRQ,ZY,JZFX,JE,ID,YHLSH,BZ,BZDBH,VENDOR_CODE,VENDOR_NAME,BOSS_FILE_NAME,BOSS_NUMBER,BOSS_UNIT_NAME,ACCOUNT_NUMBER  ");
            pzUpdateSql.append(" from FCOEZFDZCWPZFL ");
            pzUpdateSql.append(" WHERE ZHBH = #{ZHBH} AND BZ = #{BZ} ");
            pzUpdateSql.append(" ) T2 on (DJNM=T2.ID) ");
            pzUpdateSql.append(" when matched then ");
            pzUpdateSql.append(" update set ");
            pzUpdateSql.append(" JSFS = T2.JSFS, ");
            pzUpdateSql.append(" PZBH = T2.PZBH, ");
            pzUpdateSql.append(" PJBH = T2.BZDBH, ");
            pzUpdateSql.append(" YWRQ = T2.PZRQ, ");
            pzUpdateSql.append(" ZY = T2.ZY, ");
            pzUpdateSql.append(" SFLX = T2.JZFX, ");
            pzUpdateSql.append(" JE = T2.JE, ");
            pzUpdateSql.append(" YHLSH = T2.YHLSH, ");
            pzUpdateSql.append(" BZ = T2.BZ, ");
            pzUpdateSql.append(" BZDBH = T2.BZDBH, ");
            pzUpdateSql.append(" VENDOR_CODE = T2.VENDOR_CODE, ");
            pzUpdateSql.append(" VENDOR_NAME  = T2.VENDOR_NAME, ");
            pzUpdateSql.append(" BOSS_FILE_NAME = T2.BOSS_FILE_NAME, ");
            pzUpdateSql.append(" BOSS_NUMBER = T2.BOSS_NUMBER, ");
            pzUpdateSql.append(" BOSS_UNIT_NAME = T2.BOSS_UNIT_NAME, ");
            pzUpdateSql.append(" ACCOUNT_NUMBER = T2.ACCOUNT_NUMBER ");
            Map pzUpdateMap = new HashMap();   //构造Sql执行参数化执行的参数Map
            pzUpdateMap.put("ZHBH", zhbh);
            pzUpdateMap.put("BZ", bz);
            int pznum = sqlSession().insert(pzUpdateSql.toString(), pzUpdateMap);

target 结构解析

Java 项目中生成的 target 目录通常是在使用构建工具（如 Maven 或 Gradle）进行构建时产生的。这个目录包含了项目的构建输出，如编译后的类文件、生成的资源、测试报告、打包的 JAR/WAR 文件等。以下是 target 目录中一些常见文件和子目录及其作用：

1. classes：

   • 包含项目中所有 Java 源文件（.java）编译后的类文件（.class）。
   • 这是编译阶段的主要输出，是运行项目所必需的。

2. generated-sources：

   • 某些插件或工具可能会在此目录下生成额外的源代码。
   • 例如，注解处理器（Annotation Processors）或代码生成库可能会在这里放置生成的代码。

3. generated-test-sources：

   • 与 generated-sources 类似，但专门用于测试代码。
   • 这可能包括由测试框架或代码生成工具生成的测试辅助代码。

4. maven-archiver：

   • Maven 插件可能会在此目录下生成临时文件，用于构建 JAR、WAR 或 EAR 等归档文件。

5. maven-status：

   • Maven 可能会在此目录下放置有关构建进度的状态信息。

6. surefire-reports：

   • 包含项目的测试报告。
   • 这通常包括每个测试的结果、堆栈跟踪（如果测试失败）以及测试覆盖率信息。

7. test-classes：

   • 包含测试源代码（通常在 src/test/java）编译后的类文件。
   • 这是测试阶段的主要输出，用于运行项目的单元测试。

8. 最终构建的 JAR/WAR/EAR 文件：

   • 根据项目的配置和类型，target 目录可能还包含打包后的 JAR（Java 归档）、WAR（Web 归档）或 EAR（企业归档）文件。
   • 这些文件包含了项目的所有依赖项和编译后的代码，通常用于部署到服务器或作为分发包。

注意，target 目录的内容可能会因构建工具、插件和项目的具体配置而有所不同。但上述内容是一般 Java 项目中常见的文件和子目录。

BeanUtils 选择与使用

使用 org.apache.commons.beanutils 下的比较好

BeanUtils.copyProperties(fcoehbtzckblzq, fcoehbtzckblzqdj);

RPC 远程过程调用 直接调用服务器代码里的函数(就像本地调用) Restful 基于HTTP协议

RPC，全称为 Remote Procedure Call，即远程过程调用，它是一个计算机通信协议。它允许像调用本地服务一样调用远程服务。它可以有不同的实现方式，而不需要了解底层网络技术的协议。 RPC 协议假定某些传输协议的存在，如 TCP 或 UDP，为通信程序之间携带信息数据。如 RMI（远程方法调用）、Hessian、Http invoker 等。

RPC 架构分为三部分：
服务提供者，运行在服务器端，提供服务接口定义与服务实现类。
服务中心，运行在服务器端，负责将本地服务发布成远程服务，管理远程服务，提供给服务消费者使用。
服务消费者，运行在客户端，通过远程代理对象调用远程服务。

RESTful：是基于HTTP协议设计的，着重于资源的定义和管理，通过URL、HTTP方法和参数等方式进行资源的访问和操作。
RPC：是基于函数调用的，着重于接口的定义和数据传输格式的规范，通过序列化和反序列化来实现远程调用。

参考网址
restful 和 rpc请求的区别
REST -> REST,SOAP,RPC,SOA,微服务区别

调用接口–REST包含请求头的形式

//调用http
// 创建http 请求头 POST请求
HttpHeaders httpHeaders = new HttpHeaders();
httpHeaders.add(“Accept-Language”, “zh-CHS”);
httpHeaders.add(“X-ECC-Current-Tenant”, “10000”);
httpHeaders.add(“Authorization”, “Bearer c5612b75-27bc-e6cb-25a8-15e5d6586d72”);

             httpHeaders.setContentType(MediaType.parseMediaType(MediaType.APPLICATION_JSON_UTF8_VALUE));
             //发送http请求
             HttpEntity<Map>  request = new HttpEntity<>(entity, httpHeaders);
             String url = "";
             ResponseEntity<JSONObject> jsonObjectResponseEntity = RestTemplateUtils.get(yzjk_url,request,JSONObject.class);
             log.info("阅知接口调用平台接口返回报文: {}", JSON.toJSON(jsonObjectResponseEntity));
 
             //if (jsonObjectResponseEntity.) {
             // aa = aa +1;
            //}

@Mapper

@Mapper
public interface SourceTargetMapper {
    SourceTargetMapper INSTANCE = Mappers.getMapper(SourceTargetMapper.class);
    @Mappings({
            @Mapping(source = "SOURCESYSTEMID",target = "sourcesystemid"),
            @Mapping(source = "SOURCESYSTEMNAME" ,target = "sourcesystemname"),
            @Mapping(source = "TOKEN" ,target = "token"),
            @Mapping(source = "USERID",target = "userId"),
            @Mapping(source = "USERNAME",target = "userName"),
            @Mapping(source = "USERPASSWD",target = "userPasswd"),
            @Mapping(source = "SUBMITDATE",target = "submitDate"),
            @Mapping(source = "PAGESIZE",target = "pageSize"),
            @Mapping(source = "CURRENTPAGE",target = "currentPage"),
            @Mapping(source = "TOTALRECORD",target = "totalRecord"),
            @Mapping(source = "PROVINCECODE",target = "provinceCode"),
            @Mapping(source = "ROUTECODE",target = "routeCode"),
            @Mapping(source = "TRACEID",target = "traceId"),
            @Mapping(source = "RESERVED1",target = "reserved1"),
            @Mapping(source = "RESERVED2",target = "reserved2")
    })
    Sysimsgheaderlog Sysimsgheaderlog(MSGHEADER msgheader);

    @Mappings({
            @Mapping(source = "PRIKEY",target = "priKey"),
            @Mapping(source = "ACTION",target = "action"),
            @Mapping(source = "UNIQUEIDENTIDY",target = "uniqueIdentidy"),
            @Mapping(source = "BANKACCOUNT",target = "bankAccount"),
            @Mapping(source = "ACCOUNTNAME",target = "accountName"),
            @Mapping(source = "ACCOUNTCLASSIFICATION",target = "accountClassification"),
            @Mapping(source = "HIGHERACCOUNT",target = "higherAccount"),
            @Mapping(source = "UNIONBANK",target = "unionBank"),
            @Mapping(source = "CORPORATEBANK",target = "corporateBank"),
            @Mapping(source = "BANKNAME",target = "bankName"),
            @Mapping(source = "ORGCODE",target = "orgCode"),
            @Mapping(source = "AFFILIATION",target = "affiliation"),
            @Mapping(source = "USEUNIT",target = "useUnit"),
            @Mapping(source = "CURRENCYCODE",target = "currencyCode"),
            @Mapping(source = "ACCOUNTCATEGORY",target = "accountCategory"),
            @Mapping(source = "ACCOUNTSTATUS",target = "accountStatus"),
            @Mapping(source = "OPENINGDATE",target = "openingDate"),
            @Mapping(source = "SALESDATE",target = "salesDate"),
            @Mapping(source = "COUNTRY",target = "country"),
            @Mapping(source = "PROVINCE",target = "province"),
            @Mapping(source = "CITY",target = "city"),
            @Mapping(source = "TYPE",target = "type"),
            @Mapping(source = "INPUTEXT",target = "inputExt")
    })
    Sysibankacctlog setSysibankacctlog(INPUTCOLLECTIONITEM inputcollectionitem);
}

参考地址 参考地址

json解析

@JsonProperty(“MSGHEADER”)
json 转对象时 加了就会找 没有的话 最好别加

@JSONField(serialze = false)
不序列化 --对象转json时 false 可以在返回json形式响应参数体的时候去除某个字段

@XmlTransient
用途：此注释用于排除字段或属性映射到 XML。
用法：您可以用 来注释字段或属性，@XmlTransient以指示它不应包含在 XML 表示中。

@XmlElement(name = “RESPONSECOLLECTION”, required = true)
用途：此注释用于在映射字段或属性时指定 XML 元素的名称。
用法：您可以使用注释字段或属性来@XmlElement(name = “elementName”)指定 XML 元素的名称。

@JsonSerialize

@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "OutputParameters", propOrder = {
    "esbflag",
    "esbreturncode",
    "esbreturnmessage",
    "bizserviceflag",
    "bizreturncode",
    "bizreturnmessage",
    "instanceid",
    "errorcollection",
    "responsecollection"
})
public class OutputParameters {
    @JSONField(name = "ESB_FLAG")
    @XmlElement(name = "ESB_FLAG", required = true, nillable = true)
    protected String esbflag;
    @JSONField(name = "ESB_RETURN_CODE")
    @XmlElement(name = "ESB_RETURN_CODE", required = true, nillable = true)
    protected String esbreturncode;
    @JSONField(name = "ESB_RETURN_MESSAGE")
    @XmlElement(name = "ESB_RETURN_MESSAGE", required = true, nillable = true)
    protected String esbreturnmessage;
    @JSONField(name = "BIZ_SERVICE_FLAG")
    @XmlElement(name = "BIZ_SERVICE_FLAG", required = true, nillable = true)
    protected String bizserviceflag;
    @JSONField(name = "BIZ_RETURN_CODE")
    @XmlElement(name = "BIZ_RETURN_CODE", required = true, nillable = true)
    protected String bizreturncode;
    @JSONField(name = "BIZ_RETURN_MESSAGE")
    @XmlElement(name = "BIZ_RETURN_MESSAGE", required = true, nillable = true)
    protected String bizreturnmessage;
    @JSONField(name = "INSTANCE_ID")
    @XmlElement(name = "INSTANCE_ID", required = true, nillable = true)
    protected String instanceid;
    @JSONField(serialize = false)
    @XmlElement(name = "ERRORCOLLECTION", required = true)
    protected ERRORCOLLECTION errorcollection;

    @JSONField(serialize = false)
    @XmlElement(name = "RESPONSECOLLECTION", required = true)
    protected RESPONSECOLLECTION responsecollection;

    @JSONField(name = "ERRORCOLLECTION")
    @XmlTransient
    protected List<ERRORCOLLECTIONITEM> errorcollectionitem;

    @JSONField(name = "ERRORCOLLECTION")
    @XmlTransient // 如果不注掉 就要在类上方 XmlType -> propOrder 中添加这个参数了
    protected List<RESPONSECOLLECTIONITEM> responsecollectionitem;

    public List<ERRORCOLLECTIONITEM> getErrorcollectionitem() {
        if(errorcollection==null)
        {
            errorcollection = new ERRORCOLLECTION();
        }
        return errorcollection.getERRORCOLLECTIONITEM();
    }
    public List<RESPONSECOLLECTIONITEM> getResponsecollectionitem() {
        if(responsecollection==null)
        {
            responsecollection = new RESPONSECOLLECTION();
        }
        return responsecollection.getRESPONSECOLLECTIONITEM();
    }
    public void setErrorcollectionitem(List<ERRORCOLLECTIONITEM> value) {
        this.errorcollectionitem = value;
    }
    public void setResponsecollectionitem(List<RESPONSECOLLECTIONITEM> value) {
        this.responsecollectionitem = value;
    }
    /**
     * 获取esbflag属性的值。
     * 
     * @return
     *     possible object is
     *     {@link String }
     *     
     */
    public String getESBFLAG() {
        return esbflag;
    }

    /**
     * 设置esbflag属性的值。
     * 
     * @param value
     *     allowed object is
     *     {@link String }
     *     
     */
    public void setESBFLAG(String value) {
        this.esbflag = value;
    }

    /**
     * 获取esbreturncode属性的值。
     * 
     * @return
     *     possible object is
     *     {@link String }
     *     
     */
    public String getESBRETURNCODE() {
        return esbreturncode;
    }

    /**
     * 设置esbreturncode属性的值。
     * 
     * @param value
     *     allowed object is
     *     {@link String }
     *     
     */
    public void setESBRETURNCODE(String value) {
        this.esbreturncode = value;
    }

    /**
     * 获取esbreturnmessage属性的值。
     * 
     * @return
     *     possible object is
     *     {@link String }
     *     
     */
    public String getESBRETURNMESSAGE() {
        return esbreturnmessage;
    }

    /**
     * 设置esbreturnmessage属性的值。
     * 
     * @param value
     *     allowed object is
     *     {@link String }
     *     
     */
    public void setESBRETURNMESSAGE(String value) {
        this.esbreturnmessage = value;
    }

    /**
     * 获取bizserviceflag属性的值。
     * 
     * @return
     *     possible object is
     *     {@link String }
     *     
     */
    public String getBIZSERVICEFLAG() {
        return bizserviceflag;
    }

    /**
     * 设置bizserviceflag属性的值。
     * 
     * @param value
     *     allowed object is
     *     {@link String }
     *     
     */
    public void setBIZSERVICEFLAG(String value) {
        this.bizserviceflag = value;
    }

    /**
     * 获取bizreturncode属性的值。
     * 
     * @return
     *     possible object is
     *     {@link String }
     *     
     */
    public String getBIZRETURNCODE() {
        return bizreturncode;
    }

    /**
     * 设置bizreturncode属性的值。
     * 
     * @param value
     *     allowed object is
     *     {@link String }
     *     
     */
    public void setBIZRETURNCODE(String value) {
        this.bizreturncode = value;
    }

    /**
     * 获取bizreturnmessage属性的值。
     * 
     * @return
     *     possible object is
     *     {@link String }
     *     
     */
    public String getBIZRETURNMESSAGE() {
        return bizreturnmessage;
    }

    /**
     * 设置bizreturnmessage属性的值。
     * 
     * @param value
     *     allowed object is
     *     {@link String }
     *     
     */
    public void setBIZRETURNMESSAGE(String value) {
        this.bizreturnmessage = value;
    }

    /**
     * 获取instanceid属性的值。
     * 
     * @return
     *     possible object is
     *     {@link String }
     *     
     */
    public String getINSTANCEID() {
        return instanceid;
    }

    /**
     * 设置instanceid属性的值。
     * 
     * @param value
     *     allowed object is
     *     {@link String }
     *     
     */
    public void setINSTANCEID(String value) {
        this.instanceid = value;
    }

    /**
     * 获取errorcollection属性的值。
     * 
     * @return
     *     possible object is
     *     {@link ERRORCOLLECTION }
     *     
     */
    public ERRORCOLLECTION getERRORCOLLECTION() {
        return errorcollection;
    }

    /**
     * 设置errorcollection属性的值。
     * 
     * @param value
     *     allowed object is
     *     {@link ERRORCOLLECTION }
     *     
     */
    public void setERRORCOLLECTION(ERRORCOLLECTION value) {
        this.errorcollection = value;
    }

    /**
     * 获取responsecollection属性的值。
     * 
     * @return
     *     possible object is
     *     {@link RESPONSECOLLECTION }
     *     
     */
    public RESPONSECOLLECTION getRESPONSECOLLECTION() {
        return responsecollection;
    }

    /**
     * 设置responsecollection属性的值。
     * 
     * @param value
     *     allowed object is
     *     {@link RESPONSECOLLECTION }
     *     
     */
    public void setRESPONSECOLLECTION(RESPONSECOLLECTION value) {
        this.responsecollection = value;
    }
	
}

JSON 转 Object

// 低级(常见)写法
List<Fcoehbplsqfz> fcoehbplsqfzList = JSON.parseObject(dsCdArrObj, List.class); 
// 高级写法
List<Fcoehbplsqfz> fcoehbplsqfzList = JSON.parseObject(curfzstr, new TypeToken<List<Fcoehbplsqfz>>() {}.getType());

String类型的日期 计算天数之差

DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyyMMdd");
LocalDate DQRQ = LocalDate.parse("20220101", formatter);
LocalDate CRRQ = LocalDate.parse(cdModel.getCrrq(), formatter);
long daysBetween = ChronoUnit.DAYS.between(DQRQ, CRRQ);

RPC远程调用–个人代码封装版

GspServiceBundle 注解

package io.iec.edp.caf.rpc.api.annotation;

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target({ElementType.TYPE, ElementType.PACKAGE})
@Documented
@Retention(RetentionPolicy.RUNTIME)
public @interface GspServiceBundle {
    String applicationName() default "";

    String serviceUnitName() default "";

    String serviceName() default "";

    String servcieVersion() default "1.0.0";
}

@interface RpcServiceMethod

@Target({ElementType.METHOD})
@Documented
@Retention(RetentionPolicy.RUNTIME)
public @interface RpcServiceMethod {
    String serviceId() default "";
}

@interface RpcService

@Target({ElementType.TYPE})
@Documented
@Retention(RetentionPolicy.RUNTIME)
public @interface RpcService {
}

@interface RpcParam

@Target({ElementType.PARAMETER})
@Documented
@Retention(RetentionPolicy.RUNTIME)
public @interface RpcParam {
    String paramName() default "";

    GspSerializeType paramSerializeType() default GspSerializeType.Json;

    String customSerializeTypeRef() default "";
}

调用代码

@GspServiceBundle(applicationName="lsvo",serviceUnitName="fbse",serviceName="XnzhbgWebService")
public interface XnzhbgWebServiceApi {
    /**
     * 发送主数据接口
     */
    @RpcServiceMethod(serviceId = "com.inspur.gs.lsvo.fbse.xnzhbg.api.XnzhbgWebServiceApi.sendToMdm")
    void sendToMdm(@RpcParam(paramName = "id") String dataid,@RpcParam(paramName = "conclusionValue") String conclusionValue);

    /**
     * 复审环节校验账户信息完整性
     */
    @RpcServiceMethod(serviceId = "com.inspur.gs.lsvo.fbse.xnzhbg.api.XnzhbgWebServiceApi.checkFSInfo")
    void checkFSInfo(@RpcParam(paramName = "id") String dataid,@RpcParam(paramName = "conclusionValue") String conclusionValue);

    /**
     * 审定环节校验账户信息完整性(暂时无需)
     */
    @RpcServiceMethod(serviceId = "com.inspur.gs.lsvo.fbse.xnzhbg.api.XnzhbgWebServiceApi.checkSDInfo")
    void  checkSDInfo(@RpcParam(paramName = "id") String dataid,@RpcParam(paramName = "conclusionValue") String conclusionValue);
    /**
     * @Title: passZJZHXNBGSQ
     * @Description: 虚拟账户变更COA接口调用
     * @param: dataid
     * @param: conclusionValue  
     * @return void 
     * @throws  
     */
    @RpcServiceMethod(serviceId = "com.inspur.gs.lsvo.fbse.xnzhbg.api.XnzhbgWebServiceApi.getCOAInterFace")
    boolean getCOAInterFace(@RpcParam(paramName = "dataid") String dataid,@RpcParam(paramName = "conclusionValue") String conclusionValue,@RpcParam(paramName = "ssdwbh") String ssdwbh);
    /**
     * @Title: passXNBGSQCNBC
     * @Description: 虚拟账户变更出纳补充校验
     * @param: dataid
     * @param: conclusionValue
     * @return void
     * @throws
     */
    @RpcServiceMethod(serviceId = "com.inspur.gs.lsvo.fbse.xnzhbg.api.XnzhbgWebServiceApi.passXNBGSQCNBC")
    void passXNBGSQCNBC(@RpcParam(paramName = "dataid") String dataid,@RpcParam(paramName = "conclusionValue") String conclusionValue);
    /**
     * @Title: checkXNBGSQCOA
     * @Description: 虚拟账户变更Coa检查
     * @param: dataid
     * @param: conclusionValue
     * @return boolean
     * @throws
     */
    @RpcServiceMethod(serviceId = "com.inspur.gs.lsvo.fbse.xnzhbg.api.XnzhbgWebServiceApi.checkXNBGSQCOA")
    boolean checkXNBGSQCOA(@RpcParam(paramName = "dataid") String dataid,@RpcParam(paramName = "conclusionValue") String conclusionValue);
}

匿名内部类 满足条件后改写 -> Lambda写法 有严格条件要求的！！！不适用全部 只有个别情况满足

new 接口/父类（参数）{

​ 实现方法1（）{

​ }

} ；

public static void main(String[] args) {
        Comparator<String> comparator;
        // 原写法
		
        comparator = new Comparator<String>() {
            @Override
            public int compare(String first, String second) {
                int lenNum = first.length() - second.length();
                if (lenNum > 0) return 1;
                if (lenNum < 0) return 0;
                return 0;
            }
        };

        // Lambda 写法
        comparator = (first, second) ->{
            int lenNum = first.length() - second.length();
            if (lenNum > 0) return 1;
            if (lenNum < 0) return 0;
            return 0;
        };
    }
}

// Runnable 是接口 接口且只有一个抽象方法才能使用lambda表达式 就相当于 新建了一个类重写@override 这个接口的方法
public interface Executor {

    /**
     * Executes the given command at some time in the future.  The command
     * may execute in a new thread, in a pooled thread, or in the calling
     * thread, at the discretion of the {@code Executor} implementation.
     *
     * @param command the runnable task
     * @throws RejectedExecutionException if this task cannot be
     * accepted for execution
     * @throws NullPointerException if command is null
     */
    void execute(Runnable command);
}

例子2 匿名内部类 该匿名内部类实例化完成后就销毁了，不能进行第二次实例化，但可以继续使用实例化的对象。也就是说对象还存在，类不存在了。

class AnnoymousInnerClass{
    private int n = 10;
    public void show(){
        IA mao = new IA(){//编译类型为IA，运行类型为匿名内部类（AnnoymousInnerClass$1）

            @Override
            public void say() {
                System.out.println("小喵喵喵叫");
            }
        };
        
        Person han = new Person("韩"){};//编译类型为Person，运行类型为匿名内部类（AnnoymousInnerClass$2）  han(对象)还在 类不在了
        
        
        // 调用(接口形式匿名内部类)
        mao.say();
        System.out.println(mao);
        
        // 调用(类形式匿名内部类)
        System.out.println(han);
    }
}
interface IA{
    void say();
}
class Person{
    private String name;

    public Person(String name) {
        this.name = name;
    }
}
// 若不加{}为IPerson han = new Person(“韩”);则会创建一个Person类对象。在这相当于创建了一个Person的子类对象，将地址赋给父类（向上转型的用法相同）

抽象方法 -> 接口中的方法 都是抽象方法 省略了 public 和 abstract