接口被调用的时候会自动调用他的实现类(回调机制)
至于父类子类,子类复写了父类的方法,可以单独调用父类的方法,也单独调用子类的这个方法
父类的方法父类有一份(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中,模块间的交互是至关重要的。根据调用方式的不同,可以将模块间的交互分为三种...
在LabVIEW中,回调是一种重要的编程机制,它允许用户在特定事件发生时执行特定的代码。本篇将深入探讨“labview回调范例”,以及如何通过设置鼠标移动事件来触发回调函数,并利用引用更新主界面的控件。 首先,回调...
接下来,我们需要一个事件触发者,它负责在合适的时机调用回调对象的方法: ```java public class EventProducer { private EventCallback callback; public void setCallback(EventCallback callback) { this....
4. 系统在事件循环中调用回调链表中的函数,执行相应的操作。 5. 回调函数执行完毕后,可能再次触发新的回调或等待下一个事件。 在BREW的APIs中,如`ISHELL_SetTimerEx`,可能会隐式调用`ISHELL_Resume`,以便在...
- 当需要调用回调时,通过之前存储的函数指针调用: ```cpp callback(data); ``` - 在C++中触发回调的地方,确保正确地转换和传递数据到Unity。 6. **注销回调** - 在适当的时候,提供一个注销回调的接口,从...
当C++动态库接收到回调函数和结构体后,它可以在合适的时间调用回调函数,并传递修改后的结构体数据。回调函数执行完毕后,C++动态库需要释放分配的内存。 总结来说,这个工程示例展示了C#和C++之间的深度交互,...
在Java通过JNA调用DLL时,如果DLL函数需要一个回调函数作为参数,那么Java需要定义一个接口,该接口的方法将作为回调函数的实现,JNA会处理这个接口的调用转换。 4. **Spring Boot**:Spring Boot是基于Spring框架...
QT编写DLL给外部程序调用示例 方法 参数 返回值 事件回调 : 1:C#或者 NET 第一步:引入命名空间; using System Runtime InteropServices; 第二步:声明函数 必须与实际DLL中函数名及参数一致; [DllImport "qt...
Java回调机制是一种编程概念,其核心在于一个对象(A)调用另一个对象(B)的方法,而这个方法内部又反过来调用A对象的另一个方法,形成一种链式反应。回调在多线程、异步处理和事件驱动编程中非常常见,因为它允许...
在C#等语言中,通常使用事件和委托来实现回调机制。当一个事件被定义时,可以通过`+=`操作符将事件处理程序(即回调函数)与该事件关联起来。如果这个操作被执行了两次或多次,那么每次触发该事件时,对应的回调函数...
(3)当特定的事件或条件发生的时候,调用者使用函数指针调用回调函数对事件进行处理。 使用回调函数的原因是可以把调用者与被调用者分开。调用者不关心谁是被调用者,所有它需知道的,只是存在一个具有某种特定...
回调是软件设计中的一种通信机制,它允许一个函数或方法在执行过程中调用另一个预先设定的函数或方法,以响应特定事件或完成特定任务。回调机制在异步消息传递中起到关键作用,尤其是在处理非阻塞操作时,使得程序...
回调机制是计算机程序设计中的一种通信机制,它允许被调用的函数或方法反过来调用调用者提供的代码。这种机制在多线程编程、事件驱动编程和异步处理中尤其常见。回调是通过在调用函数时传递一个函数指针或者一个实现...
- **异步操作**:非托管代码可能会在后台线程中调用回调,以便在完成某项任务后通知托管代码。 - **自定义行为**:通过回调,用户可以定制非托管代码的行为,比如在遍历过程中对每个元素进行自定义处理。 以下是一...
"如何用Java回调和线程实现异步调用" 在软件开发中,异步调用是一种非阻塞式调用方式,用于在处理比较耗时的任务...通过使用Java回调和线程机制,可以实现异步调用,解决程序阻塞问题、异步消息的传递问题和超时问题。
例如,一个任务执行完成后,会调用回调接口的`onCompletion()`方法来通知调用者任务已经完成。 2. `ProxyPatternExample.java`: 这可能是实现代理模式的类,它展示了如何创建一个代理类或利用动态代理来控制对原始...
例如,如果使用一个全局变量来跟踪是否应继续调用回调,可以在适当时候修改这个变量,使回调函数在检查到这个标志后不再执行。 总结,回调函数是C语言中实现动态行为和解耦设计的关键工具。通过理解和熟练运用回调...
3. **实现回调函数**: 在DLL中,当需要调用回调函数时,使用传入的函数指针来调用应用程序的回调函数。 4. **调用回调函数**: 在适当的时机,DLL调用回调函数,执行应用程序提供的逻辑。 5. **卸载DLL**: 应用程序...