接口被调用的时候会自动调用他的实现类(回调机制)
至于父类子类,子类复写了父类的方法,可以单独调用父类的方法,也单独调用子类的这个方法
父类的方法父类有一份(super),子类有一份(this),通过子类调用父类方法这个this就是子类本身,
单独调用父类用super,那么封装在父类的方法直接用this.调用即可之后哪个子类调用就是谁
父:
package com.esteel.settlement.pa.packet;
import java.io.Serializable;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.nio.charset.Charset;
import java.text.DecimalFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.LinkedList;
import java.util.List;
import javax.validation.constraints.NotNull;
import javax.validation.constraints.Pattern;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlTransient;
import org.hibernate.validator.constraints.Length;
import org.hibernate.validator.constraints.NotEmpty;
import org.springframework.format.annotation.DateTimeFormat;
import org.springframework.util.Assert;
import org.springframework.util.StringUtils;
/**
* 平安对接接口的基类 用于对数据格式的转换
*
* @author zhangxiuzhi
*
*/
@XmlAccessorType(XmlAccessType.FIELD)
public abstract class PaPacket implements Serializable {
public static String RMB = "RMB";
public static String SUCCESS = "000000";
public static SimpleDateFormat SFDate = new SimpleDateFormat("yyyyMMdd");
DecimalFormat df = new DecimalFormat("######0.00");
Charset charset = Charset.forName("GBK");
// 报文请求类型 请求
public static String REQUEST = "01";
// 报文请求类型 请求
public static String RESPONSE = "02";
// 保留域
@XmlElement(name = "Reserve")
private String reserve;
@XmlTransient
protected PacketHeader packetHeader = new PacketHeader();
@XmlTransient
protected BusinessHeader buisinessHeader = new BusinessHeader();
// 交易网代码
@XmlTransient
@NotEmpty
private String qydm;
// 交易网流水号
@XmlElement(name = "ThirdLogNo")
@Length(max = 20)
@NotEmpty
private String thirdLogNo;
// 服务类型
@XmlTransient
@NotEmpty
@Pattern(regexp = "01|02")
private String servType;
// 交易时间
@XmlTransient
@NotNull
@DateTimeFormat(pattern = "yyyyMMdd")
private Date transDate;
// 操作员号
@XmlTransient
private String counterId;
// 交易码
@XmlTransient
@NotNull
@Length(min = 1, max = 4)
private String tranFunc;
public PaPacket(){
this.setTranFunc(tranFunc());
}
protected abstract String tranFunc();
public String getReserve() {
return reserve;
}
public void setReserve(String reserve) {
this.reserve = reserve;
}
public String getQydm() {
return qydm;
}
public void setQydm(String qydm) {
this.qydm = qydm;
// 交易网代码
this.packetHeader.setQydm(this.getQydm());
this.buisinessHeader.setQydm(this.qydm);
}
public String getThirdLogNo() {
return thirdLogNo;
}
public void setThirdLogNo(String thirdLogNo) {
this.thirdLogNo = thirdLogNo;
// 请求系统流水号
this.packetHeader.setThirdLogNo(this.getThirdLogNo());
this.buisinessHeader.setThirdLogNo(this.getThirdLogNo());
}
public String getServType() {
return servType;
}
public void setServType(String servType) {
this.servType = servType;
// 服务类型 01 请求 02 应答
this.packetHeader.setServType(this.getServType());
this.buisinessHeader.setServType(this.getServType());
}
public Date getTransDate() {
return transDate;
}
public void setTransDate(Date transDate) {
this.transDate = transDate;
// 交易时间
this.packetHeader.setTranDate(this.getTransDate());
this.buisinessHeader.setTranDate(this.getTransDate());
}
public String getCounterId() {
return counterId;
}
public void setCounterId(String counterId) {
this.counterId = counterId;
// 操作员号
this.packetHeader.setCounterId(counterId);
this.buisinessHeader.setCounterId(counterId);
}
public String getTranFunc() {
return tranFunc;
}
public void setTranFunc(String tranFunc) {
this.tranFunc = tranFunc;
this.buisinessHeader.setTranFunc(tranFunc);
}
public void setRspCode(String rspCode) {
this.buisinessHeader.setRspCode(rspCode);
this.packetHeader.setRspCode(rspCode);
}
public String getRspCode() {
return this.buisinessHeader.getRspCode();
}
public void setRspMsg(String rspMsg) {
this.buisinessHeader.setRspMsg(rspMsg);
this.packetHeader.setRspMsg(rspMsg);
}
public String getRspMsg() {
return this.buisinessHeader.getRspMsg();
}
/**
* 解析报文头
*
* @param packetHeader
*/
private void analyzePacketHeader(byte[] packetHeader) {
this.packetHeader.analyze(packetHeader);
}
/**
* 解析业务报文头
*
* @param businesserHeader
*/
private void analyzeBusinsserHeader(byte[] businesserHeader) {
this.buisinessHeader.analyze(businesserHeader);
}
/**
* 将报文编组成可以发送的字符串报文
*
* @return
*/
public String marshal() {
Assert.notNull(this.packetHeader);
Assert.notNull(this.buisinessHeader);
// 业务报问题
String data = this.getString();
// 设置报文中的公共的值
// 交易网代码
this.packetHeader.setQydm(this.getQydm());
this.buisinessHeader.setQydm(this.qydm);
// 请求系统流水号
this.packetHeader.setThirdLogNo(this.getThirdLogNo());
this.buisinessHeader.setThirdLogNo(this.getThirdLogNo());
// 服务类型 01 请求 02 应答
this.packetHeader.setServType(this.getServType());
this.buisinessHeader.setServType(this.getServType());
// 交易时间
this.packetHeader.setTranDate(this.getTransDate());
this.buisinessHeader.setTranDate(this.getTransDate());
// 设置报文长度
this.packetHeader.setPacketLength(BusinessHeader.HEADERLEN + data.getBytes(charset).length);
this.buisinessHeader.setLength(data.getBytes(charset).length);
// 操作员号
this.packetHeader.setCounterId(this.getCounterId());
this.buisinessHeader.setCounterId(this.getCounterId());
// 设置操作代码
// this.buisinessHeader.setTranFunc(this.getTranFunc());
byte[] cs = this.packetHeader.getPacketHeader();
StringBuilder sb = new StringBuilder();
sb.append(new String(cs, charset));
sb.append(new String(this.buisinessHeader.getBusinessHeader(), charset));
sb.append(data);
return sb.toString();
}
/**
* 生成需要的报文字符串
*
* @return
*/
public String getString() {
StringBuilder sb = new StringBuilder();
try {
for (String fName : this.order()) {
Object obj = getValue(fName);
if (obj == null) {
sb.append("");
}
if (obj instanceof String) {
sb.append((String) obj);
}
if (obj instanceof Integer) {
sb.append(((Integer) obj).intValue());
}
if (obj instanceof Long) {
sb.append(((Long) obj).intValue());
}
if (obj instanceof Double) {
sb.append(df.format((Double) obj));
}
if (obj instanceof Date) {
sb.append(SFDate.format(obj));
}
sb.append("&");
}
} catch (NoSuchFieldException | SecurityException | NoSuchMethodException | IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
e.printStackTrace();
}
// sb.deleteCharAt(sb.length() - 1);
return sb.toString();
}
/**
* 取得属性名字时 用于获得属性值
*
* @param fName
* @return
* @throws NoSuchFieldException
* @throws SecurityException
* @throws NoSuchMethodException
* @throws IllegalAccessException
* @throws IllegalArgumentException
* @throws InvocationTargetException
*/
private Object getValue(String fName) throws NoSuchFieldException, SecurityException, NoSuchMethodException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
fName = fName.substring(0, 1).toUpperCase() + fName.substring(1);
Method method = this.getClass().getMethod("get" + fName);
Assert.notNull(method);
return method.invoke(this);
}
/**
* 设置对象的值
*
* @param fName
* @param value
* @throws NoSuchMethodException
* @throws SecurityException
* @throws NoSuchFieldException
* @throws IllegalArgumentException
* @throws IllegalAccessException
* @throws InvocationTargetException
* @throws ParseException
*/
private void setValue(Object obj,String fieldName, List<String> values)
throws NoSuchMethodException, SecurityException, NoSuchFieldException, IllegalArgumentException, IllegalAccessException, InvocationTargetException, ParseException {
if (values == null||values.isEmpty()) {
return;
}
//用于判断是否去掉values中的第一个元素,默认情况删除,但在处理递归调用的时候 不删除
boolean isMove=true;
String value = values.get(0);
String fName = fieldName.substring(0, 1).toUpperCase() + fieldName.substring(1);
Method get = obj.getClass().getMethod("get" + fName);
Method method = obj.getClass().getMethod("set" + fName, get.getReturnType());
Assert.notNull(method);
switch (get.getReturnType().getSimpleName()) {
case "String": {
method.invoke(obj, value);
break;
}
case "int":
case "Integer": {
if (value.indexOf(".") > -1) {
value = value.substring(0, value.indexOf("."));
}
method.invoke(obj, new Integer(value));
break;
}
case "double":
case "Double": {
method.invoke(obj, df.parse(value));
break;
}
case "long":
case "Long": {
if (value.indexOf(".") > -1) {
value = value.substring(0, value.indexOf("."));
}
method.invoke(obj, new Long(value));
break;
}
case "Date": {
try{
Date date = SFDate.parse(value);
method.invoke(obj, date);
}catch(Exception ex){
}
break;
}
case "List":{
Field field = obj.getClass().getDeclaredField(fieldName);
ArraySizeMethod arraySizeMethod = field.getAnnotation(ArraySizeMethod.class);
//循环记录的条数 默认1
int numSize = 1;
if (arraySizeMethod!=null){
String sizeMethodName = arraySizeMethod.value();
if (!StringUtils.isEmpty(sizeMethodName)){
Method sizeMethod = obj.getClass().getMethod(sizeMethodName);
numSize = ((int) sizeMethod.invoke(obj));
}
}
List<ResultArray> list = new ArrayList<ResultArray>();
Type fc = field.getGenericType();
if (fc instanceof ParameterizedType){
ParameterizedType pt = (ParameterizedType) fc;
Class<?> genericClazz = (Class<?>)pt.getActualTypeArguments()[0];
try {
ResultArray result = (ResultArray) genericClazz.newInstance();
String[] orders = result.order();
for (int i=0;i<numSize;i++){
for (String str : orders){
setValue(result,str,values);
}
list.add(result);
result = (ResultArray) genericClazz.newInstance();
}
} catch (InstantiationException e) {
e.printStackTrace();
}
}
method.invoke(obj, list);
isMove = false;
break;
}
default:{
System.out.println(get.getReturnType().getSimpleName());
}
}
//去掉队列中的第一个元素
if (isMove){
values.remove(0);
}
}
/**
* 根据各处的
*
* @param str
*/
public void analyze(String packetStr) {
byte[] src = packetStr.getBytes(charset);
Assert.isTrue(src.length > 344);
byte[] ph = new byte[222];
byte[] bh = new byte[122];
System.arraycopy(src, 0, ph, 0, ph.length);
System.arraycopy(src, 222, bh, 0, bh.length);
this.analyzePacketHeader(ph);
this.analyzeBusinsserHeader(bh);
byte[] data = new byte[src.length - 344];
System.arraycopy(src, 344, data, 0, data.length);
String str = new String(data, charset);
// 将头文件中的属性值设置到公共报文中
this.setCounterId(this.buisinessHeader.getCounterId());
this.setQydm(this.buisinessHeader.getQydm());
this.setTransDate(this.buisinessHeader.getTranDate());
this.setServType(this.buisinessHeader.getServType());
this.setThirdLogNo(this.buisinessHeader.getThirdLogNo());
this.setTranFunc(this.buisinessHeader.getTranFunc());
String[] strs = str.split("&");
List<String> list = new LinkedList<String>();
list.addAll(Arrays.asList(strs));
String[] fNames = this.order();//////////////////////////////////////谁调用就指谁
String[] values = new String[fNames.length];
System.arraycopy(strs, 0, values, 0, values.length > strs.length ? strs.length : values.length);
// Assert.isTrue(fNames.length >= strs.length);
//int index = 0;
try {
for (String fname : fNames) {
//setValue(fname, values[index]);
setValue(this,fname, list);
//index++;
}
} catch (NoSuchMethodException | SecurityException | NoSuchFieldException | IllegalArgumentException | IllegalAccessException | InvocationTargetException | ParseException e) {
e.printStackTrace();
}
}
/**
* 返回报文的生成顺序
*
* @return
*/
protected abstract String[] order();
}
子类:
@Test
public void testAnsyze(){
String str = "1&2&3&4&5&6&7&8&9&10&11&12&13&14&15&";
BP1303 bp = new BP1303();
bp.analyze(str);
System.out.println(bp.getString());
}
子类覆写父类:
@Override
protected String[] order() {
String[] objs = {"funcFlag","supAcctId","custAcctId","custName","thirdCustId","idType","idCode","relatedAcctId","acctFlag","tranType","acctName","bankCode","bankName","oldRelatedAcctId","reserve"};
return objs;
}
==================
回调机制在系统配置的时候体现:
public class CustomUserDetailsService
implements AuthenticationUserDetailsService<CasAssertionAuthenticationToken> {
@Override
public UserDetails loadUserDetails(CasAssertionAuthenticationToken token) throws UsernameNotFoundException {
System.out.println("当前的用户名是:"+token.getName());
/*这里我为了方便,就直接返回一个用户信息,实际当中这里修改为查询数据库或者调用服务什么的来获取用户信息*/
UserInfo userInfo = new UserInfo();
userInfo.setUsername(token.getName());
userInfo.setName(token.getName());
Set<AuthorityInfo> authorities = new HashSet<AuthorityInfo>();
AuthorityInfo authorityInfo = new AuthorityInfo("TEST");
authorities.add(authorityInfo);
userInfo.setAuthorities(authorities);
return userInfo;
}
@Bean
public AuthenticationUserDetailsService<CasAssertionAuthenticationToken> customUserDetailsService() {
return new CustomUserDetailsService();
}
相关推荐
Android 中的回调机制是一种方法调用机制,类似于 C++ 语言中的指针传递,使其它类或方法掌握另一个类的句柄。Java 中的回调是通过接口或内部类实现的。 回调机制的实现需要两个类和一个接口,步骤如下: 1. 首先...
本主题将详细探讨如何在C#应用程序中调用C++动态链接库(DLL)中的函数,并且在这个过程中,C#能够注册和处理C++库中定义的回调函数。 首先,让我们理解回调函数的概念。回调函数是一种设计模式,允许将一个函数的...
Java回调机制是软件设计模式中的一种,特别是在Java和Android开发中广泛应用。回调允许服务端对象在执行特定操作后,通知并调用客户端对象的方法。这种机制使得程序可以在异步环境中运行,即服务端处理完一个任务后...
### Java基础核心理解+什么是回调及回调机制讲解 #### 一、回调机制的引入与应用场景 在软件开发中,特别是面向对象编程语言如Java中,模块间的交互是至关重要的。根据调用方式的不同,可以将模块间的交互分为三种...
回调机制是一种软件设计模式,它允许一个程序在执行过程中调用另一个程序提供的功能,并且这个被调用的函数会在特定事件发生时返回控制权给原始的调用者。回调机制通常用于异步处理、事件通知、功能扩展等多种场景。...
回调函数是一种允许DLL在执行过程中调用客户端代码的机制。在C++中,这通常通过指针或引用来实现,该指针或引用指向了客户端提供的函数。在本例中,C++ DLL可能定义了一个接受回调函数作为参数的接口,这样在DLL内部...
本篇文章将深入探讨如何在C++程序中调用DLL,并实现消息回调机制。 首先,我们需要理解C++调用DLL的基本步骤: 1. 创建DLL:在DLL项目中,定义一个函数,例如处理数据的函数`ProcessData`。这个函数可能接收一些...
// 耗时操作完成后,调用回调 if (callback != null) { callback.onCallback("工作已完成"); } } } ``` 在这个`WorkerThread`类中,我们设置了一个回调接口,并在`doWork`方法执行完毕后调用它。在实际应用中...
- 当需要调用回调时,通过之前存储的函数指针调用: ```cpp callback(data); ``` - 在C++中触发回调的地方,确保正确地转换和传递数据到Unity。 6. **注销回调** - 在适当的时候,提供一个注销回调的接口,从...
回调函数和回调机制是软件开发中常用的设计模式,主要用于实现异步操作、事件处理和定制化工作流程。回调函数是一个用户定义的函数,它作为参数传递给另一个函数,由该函数在适当的时间调用。这种设计允许将某些特定...
在Java通过JNA调用DLL时,如果DLL函数需要一个回调函数作为参数,那么Java需要定义一个接口,该接口的方法将作为回调函数的实现,JNA会处理这个接口的调用转换。 4. **Spring Boot**:Spring Boot是基于Spring框架...
当C++动态库接收到回调函数和结构体后,它可以在合适的时间调用回调函数,并传递修改后的结构体数据。回调函数执行完毕后,C++动态库需要释放分配的内存。 总结来说,这个工程示例展示了C#和C++之间的深度交互,...
在Android开发中,Handler回调机制是用于解决线程间通信的核心技术之一,它与Looper和Message紧密相连,共同构建了Android的消息处理系统。本篇将深入解析Handler回调机制,并通过提供的"handler的回调机制"DEMO来...
驱动回调通知机制是Windows驱动程序开发中的一个重要概念,主要用于实现系统与驱动之间的通信。在Windows Driver Kit (WDK) 中,回调函数是驱动程序与操作系统交互的一种方式,它允许操作系统在特定事件发生时调用...
首先明确一个概念,回调函数也是普通函数, 叫回调函数,是因为程序通过参数把该函数的函数指针传递给了其它函数,在那个函数里面调用这个函数指针就相当于调用这个函数,这样的过程就叫回调,而被调用的函数就叫回...
Java回调机制是一种编程概念,其核心在于一个对象(A)调用另一个对象(B)的方法,而这个方法内部又反过来调用A对象的另一个方法,形成一种链式反应。回调在多线程、异步处理和事件驱动编程中非常常见,因为它允许...
在C#等语言中,通常使用事件和委托来实现回调机制。当一个事件被定义时,可以通过`+=`操作符将事件处理程序(即回调函数)与该事件关联起来。如果这个操作被执行了两次或多次,那么每次触发该事件时,对应的回调函数...
回调函数允许DLL将控制权返回给调用者,使得调用者能够处理特定的事件或任务。本篇文章将深入探讨Delphi中DLL的回调函数及其应用。 首先,我们需要理解什么是回调函数。回调函数是一种设计模式,其中函数A作为参数...
(3)当特定的事件或条件发生的时候,调用者使用函数指针调用回调函数对事件进行处理。 使用回调函数的原因是可以把调用者与被调用者分开。调用者不关心谁是被调用者,所有它需知道的,只是存在一个具有某种特定...
回调机制则是异步编程的核心,它定义了一个接口或者抽象方法,这个方法会在特定事件发生(如操作完成)时被调用。回调函数就像一个约定,当异步任务完成时,系统会按照约定调用预先定义好的函数来处理结果。 在Java...