Hessian源码分析和Hack --让Hessian携带远程调用端的信息（上）-程序员宅基地

项目选定Hessian作为web service的实现方式，确实很轻量级，速度就跟直接用socket差不多，全是二进制传送节约了不少开销。但是在使用过程中有业务需要是必须获得远程端的ip地址，主机名等信息的。翻便Hessian的文档和google了n次未果，迫不得已到caucho和spring论坛去问，都没有得到答复。今天心一横把hessian的源代码加入到项目中单步跟踪，总算有点小收获。献丑分享出来，一方面给需要的朋友，主要还是希望各位找找是否存在bug，以及是否有更好的改良。

一：先撇开Spring不谈，来看看纯Hessian的调用
按照hessian文档里边介绍的demo，在web.xml里边如下配置

Java代码  

 <servlet>  
 <servlet-name>hello</servlet-name>  
 <servlet-class>com.caucho.hessian.server.HessianServlet</servlet-class>  
  <init-param>  
    <param-name>home-class</param-name>  
    <param-value>example.BasicService</param-value>  
  </init-param>  
  <init-param>  
    <param-name>home-api</param-name>  
    <param-value>example.Basic</param-value>  
  </init-param>  
</servlet>  
  
<servlet-mapping>  
  <url-pattern>/hello</url-pattern>  
  <servlet-name>hello</servlet-name>  
</servlet-mapping>  

由此可知Hessian调用的入口是HessianServlet这个Servlet，进去看看

Java代码  

/** 
 * Servlet for serving Hessian services. 
 */  
public class HessianServlet extends GenericServlet {  
  private Class _homeAPI;  
  private Object _homeImpl;  
    
  private Class _objectAPI;  
  private Object _objectImpl;  
    
  private HessianSkeleton _homeSkeleton;  
  private HessianSkeleton _objectSkeleton;  
  
  private SerializerFactory _serializerFactory;  
  
  public String getServletInfo()  
  {  
    return "Hessian Servlet";  
  }  
  
  /** 
   * Sets the home api. 
   */  
  public void setHomeAPI(Class api)  
  {  
    _homeAPI = api;  
  }  
  
  /** 
   * Sets the home implementation 
   */  
  public void setHome(Object home)  
  {  
    _homeImpl = home;  
  }  
  
  /** 
   * Sets the object api. 
   */  
  public void setObjectAPI(Class api)  
  {  
    _objectAPI = api;  
  }  
  
  /** 
   * Sets the object implementation 
   */  
  public void setObject(Object object)  
  {  
    _objectImpl = object;  
  }  
  
  /** 
   * Sets the service class. 
   */  
  public void setService(Object service)  
  {  
    setHome(service);  
  }  
  
  /** 
   * Sets the api-class. 
   */  
  public void setAPIClass(Class api)  
  {  
    setHomeAPI(api);  
  }  
  
  /** 
   * Gets the api-class. 
   */  
  public Class getAPIClass()  
  {  
    return _homeAPI;  
  }  
  
  /** 
   * Sets the serializer factory. 
   */  
  public void setSerializerFactory(SerializerFactory factory)  
  {  
    _serializerFactory = factory;  
  }  
  
  /** 
   * Gets the serializer factory. 
   */  
  public SerializerFactory getSerializerFactory()  
  {  
    if (_serializerFactory == null)  
      _serializerFactory = new SerializerFactory();  
  
    return _serializerFactory;  
  }  
  
  /** 
   * Sets the serializer send collection java type. 
   */  
  public void setSendCollectionType(boolean sendType)  
  {  
    getSerializerFactory().setSendCollectionType(sendType);  
  }  
  
  /** 
   * Initialize the service, including the service object. 
   */  
  public void init(ServletConfig config)  
    throws ServletException  
  {  
    super.init(config);  
      
    try {  
      if (_homeImpl != null) {  
      }  
      else if (getInitParameter("home-class") != null) {  
    String className = getInitParameter("home-class");  
      
    Class homeClass = loadClass(className);  
  
    _homeImpl = homeClass.newInstance();  
  
    init(_homeImpl);  
      }  
      else if (getInitParameter("service-class") != null) {  
    String className = getInitParameter("service-class");  
      
    Class homeClass = loadClass(className);  
  
    _homeImpl = homeClass.newInstance();  
      
    init(_homeImpl);  
      }  
      else {  
    if (getClass().equals(HessianServlet.class))  
      throw new ServletException("server must extend HessianServlet");  
  
    _homeImpl = this;  
      }  
  
      if (_homeAPI != null) {  
      }  
      else if (getInitParameter("home-api") != null) {  
    String className = getInitParameter("home-api");  
      
    _homeAPI = loadClass(className);  
      }  
      else if (getInitParameter("api-class") != null) {  
    String className = getInitParameter("api-class");  
  
    _homeAPI = loadClass(className);  
      }  
      else if (_homeImpl != null) {  
    _homeAPI = findRemoteAPI(_homeImpl.getClass());  
  
    if (_homeAPI == null)  
      _homeAPI = _homeImpl.getClass();  
      }  
        
      if (_objectImpl != null) {  
      }  
      else if (getInitParameter("object-class") != null) {  
    String className = getInitParameter("object-class");  
      
    Class objectClass = loadClass(className);  
  
    _objectImpl = objectClass.newInstance();  
  
    init(_objectImpl);  
      }  
  
      if (_objectAPI != null) {  
      }  
      else if (getInitParameter("object-api") != null) {  
    String className = getInitParameter("object-api");  
      
    _objectAPI = loadClass(className);  
      }  
      else if (_objectImpl != null)  
    _objectAPI = _objectImpl.getClass();  
  
      _homeSkeleton = new HessianSkeleton(_homeImpl, _homeAPI);  
      if (_objectAPI != null)  
    _homeSkeleton.setObjectClass(_objectAPI);  
  
      if (_objectImpl != null) {  
    _objectSkeleton = new HessianSkeleton(_objectImpl, _objectAPI);  
    _objectSkeleton.setHomeClass(_homeAPI);  
      }  
      else  
    _objectSkeleton = _homeSkeleton;  
    } catch (ServletException e) {  
      throw e;  
    } catch (Exception e) {  
      throw new ServletException(e);  
    }  
  }  
  
  private Class findRemoteAPI(Class implClass)  
  {  
    if (implClass == null || implClass.equals(GenericService.class))  
      return null;  
      
    Class []interfaces = implClass.getInterfaces();  
  
    if (interfaces.length == 1)  
      return interfaces[0];  
  
    return findRemoteAPI(implClass.getSuperclass());  
  }  
  
  private Class loadClass(String className)  
    throws ClassNotFoundException  
  {  
    ClassLoader loader = Thread.currentThread().getContextClassLoader();  
  
    if (loader != null)  
      return Class.forName(className, false, loader);  
    else  
      return Class.forName(className);  
  }  
  
  private void init(Object service)  
    throws ServletException  
  {  
    if (service instanceof Service)  
      ((Service) service).init(getServletConfig());  
    else if (service instanceof Servlet)  
      ((Servlet) service).init(getServletConfig());  
  }  
    
  /** 
   * Execute a request.  The path-info of the request selects the bean. 
   * Once the bean's selected, it will be applied. 
   */  
  public void service(ServletRequest request, ServletResponse response)  
    throws IOException, ServletException  
  {  
    HttpServletRequest req = (HttpServletRequest) request;  
    HttpServletResponse res = (HttpServletResponse) response;  
  
    if (! req.getMethod().equals("POST")) {  
      res.setStatus(500, "Hessian Requires POST");  
      PrintWriter out = res.getWriter();  
  
      res.setContentType("text/html");  
      out.println("<h1>Hessian Requires POST</h1>");  
        
      return;  
    }  
  
    String serviceId = req.getPathInfo();  
    String objectId = req.getParameter("id");  
    if (objectId == null)  
      objectId = req.getParameter("ejbid");  
  
    ServiceContext.begin(req, serviceId, objectId);  
  
    try {  
      InputStream is = request.getInputStream();  
      OutputStream os = response.getOutputStream();  
  
      Hessian2Input in = new Hessian2Input(is);  
      AbstractHessianOutput out;  
  
      SerializerFactory serializerFactory = getSerializerFactory();  
        
      in.setSerializerFactory(serializerFactory);  
  
      int code = in.read();  
  
      if (code != 'c') {  
    // XXX: deflate  
    throw new IOException("expected 'c' in hessian input at " + code);  
      }  
  
      int major = in.read();  
      int minor = in.read();  
  
      if (major >= 2)  
    out = new Hessian2Output(os);  
      else  
    out = new HessianOutput(os);  
        
      out.setSerializerFactory(serializerFactory);  
  
      if (objectId != null)  
    _objectSkeleton.invoke(in, out);  
      else  
    _homeSkeleton.invoke(in, out);  
  
      out.close();  
    } catch (RuntimeException e) {  
      throw e;  
    } catch (ServletException e) {  
      throw e;  
    } catch (Throwable e) {  
      throw new ServletException(e);  
    } finally {  
      ServiceContext.end();  
    }  
  }  
}  

先看init()函数，功能还是一样，初始话一些东西，读入init-param的内容，并且load这些init-param的class

主要的还是service()函数
在service函数里边会获得request和response对象的输入和输出流，用来构造Hessian2Input和Hessian2Output，Hessian就是解析这两个东西来执行函数调用的。当然，在service里边还有一个重要的语句

Java代码  

ServiceContext.begin(req, serviceId, objectId);  

这个函数有点奇怪，我每次到这里serviceId和objectId都是空，不知道是不是历史遗留问题还存在这两个参数。
进去这个类看看

Java代码  

public class ServiceContext {  
  private static final ThreadLocal _localContext = new ThreadLocal();  
  
  private ServletRequest _request;  
  private String _serviceName;  
  private String _objectId;  
  private int _count;  
  private HashMap _headers = new HashMap();  
  
  private ServiceContext()  
  {  
  }  
    
  /** 
   * Sets the request object prior to calling the service's method. 
   * 
   * @param request the calling servlet request 
   * @param serviceId the service identifier 
   * @param objectId the object identifier 
   */  
  public static void begin(ServletRequest request,  
               String serviceName,  
               String objectId)  
    throws ServletException  
  {  
    ServiceContext context = (ServiceContext) _localContext.get();  
  
    if (context == null) {  
      context = new ServiceContext();  
      _localContext.set(context);  
    }  
  
    context._request = request;  
    context._serviceName = serviceName;  
    context._objectId = objectId;  
    context._count++;  
  }  
  
  /** 
   * Returns the service request. 
   */  
  public static ServiceContext getContext()  
  {  
    return (ServiceContext) _localContext.get();  
  }  
  
  /** 
   * Adds a header. 
   */  
  public void addHeader(String header, Object value)  
  {  
    _headers.put(header, value);  
  }  
  
  /** 
   * Gets a header. 
   */  
  public Object getHeader(String header)  
  {  
    return _headers.get(header);  
  }  
  
  /** 
   * Gets a header from the context. 
   */  
  public static Object getContextHeader(String header)  
  {  
    ServiceContext context = (ServiceContext) _localContext.get();  
  
    if (context != null)  
      return context.getHeader(header);  
    else  
      return null;  
  }  
  
  /** 
   * Returns the service request. 
   */  
  public static ServletRequest getContextRequest()  
  {  
    ServiceContext context = (ServiceContext) _localContext.get();  
  
    if (context != null)  
      return context._request;  
    else  
      return null;  
  }  
  
  /** 
   * Returns the service id, corresponding to the pathInfo of the URL. 
   */  
  public static String getContextServiceName()  
  {  
    ServiceContext context = (ServiceContext) _localContext.get();  
  
    if (context != null)  
      return context._serviceName;  
    else  
      return null;  
  }  
  
  /** 
   * Returns the object id, corresponding to the ?id= of the URL. 
   */  
  public static String getContextObjectId()  
  {  
    ServiceContext context = (ServiceContext) _localContext.get();  
  
    if (context != null)  
      return context._objectId;  
    else  
      return null;  
  }  
  
  /** 
   * Cleanup at the end of a request. 
   */  
  public static void end()  
  {  
    ServiceContext context = (ServiceContext) _localContext.get();  
  
    if (context != null && --context._count == 0) {  
      context._request = null;  
  
      context._headers.clear();  
    }  
  }  
  
  /** 
   * Returns the service request. 
   * 
   * @deprecated 
   */  
  public static ServletRequest getRequest()  
  {  
    ServiceContext context = (ServiceContext) _localContext.get();  
  
    if (context != null)  
      return context._request;  
    else  
      return null;  
  }  
  
  /** 
   * Returns the service id, corresponding to the pathInfo of the URL. 
   * 
   * @deprecated 
   */  
  public static String getServiceName()  
  {  
    ServiceContext context = (ServiceContext) _localContext.get();  
  
    if (context != null)  
      return context._serviceName;  
    else  
      return null;  
  }  
  
  /** 
   * Returns the object id, corresponding to the ?id= of the URL. 
   * 
   * @deprecated 
   */  
  public static String getObjectId()  
  {  
    ServiceContext context = (ServiceContext) _localContext.get();  
  
    if (context != null)  
      return context._objectId;  
    else  
      return null;  
  }  
}  

原来ServiceContext 是用来保存当前调用线程的上下文的，比如request对象等（不知道这个解释对不对）。有了这个东西就太好了，因为里边有request，就有了调用端的一切信息，呵呵。

继续回来看那个Servlet，到了真正调用的时候了，也就是这段代码

Java代码  

if (objectId != null)  
ctSkeleton.invoke(in, out);  
else  
Skeleton.invoke(in, out);  

跟踪invoke方法看看真面目

Java代码  

public void invoke(AbstractHessianInput in, AbstractHessianOutput out)  
  throws Throwable  
{  
  ServiceContext context = ServiceContext.getContext();  
    
  String header;  
  while ((header = in.readHeader()) != null) {  
    Object value = in.readObject();  
  
    context.addHeader(header, value);  
  }  
  String ip = context.getContextRequest().getRemoteAddr();  
  String methodName = in.readMethod();  
  Method method = getMethod(methodName);  
  
  if (method != null) {  
  }  
  else if ("_hessian_getAttribute".equals(methodName)) {  
    String attrName = in.readString();  
    in.completeCall();  
  
    String value = null;  
  
    if ("java.api.class".equals(attrName))  
alue = getAPIClassName();  
    else if ("java.home.class".equals(attrName))  
alue = getHomeClassName();  
    else if ("java.object.class".equals(attrName))  
alue = getObjectClassName();  
  
    out.startReply();  
  
    out.writeObject(value);  
  
    out.completeReply();  
    return;  
  }  
  else if (method == null) {  
    out.startReply();  
    out.writeFault("NoSuchMethodException",  
     "The service has no method named: " + in.getMethod(),  
     null);  
    out.completeReply();  
    return;  
  }  
  
  Class []args = method.getParameterTypes();  
  Object []values = new Object[args.length];  
    
  //args[0]  
  
  for (int i = 0; i < args.length; i++){  
    if(i == args.length-1){  
        values[i] = in.readObject(args[i], ip);  
    }else{  
        values[i] = in.readObject(args[i]);  
    }  
      
  }  
      
  
  in.completeCall();  
  
  Object result = null;  
    
  try {  
    result = method.invoke(_service, values);  
  } catch (Throwable e) {  
    if (e instanceof InvocationTargetException)  
      e = ((InvocationTargetException) e).getTargetException();  
  
    log.log(Level.WARNING, e.toString(), e);  
      
    out.startReply();  
    out.writeFault("ServiceException", e.getMessage(), e);  
    out.completeReply();  
    return;  
  }  
  
  out.startReply();  
  
  out.writeObject(result);  
    
  out.completeReply();  
}  

就是在这个方法里边，hessian把包装过的输入输出流当作参数传入并进行解析的，看看这个函数的第一句，正是取得ServiceContext的地方，此时应该就是把刚才Servlet里边保存的上下文取出来使用。
这个时候出现了第一个hack的地方

Java代码  

String ip = context.getContextRequest().getRemoteAddr();  

在此处我取得远程的ip地址保存起来。然后在第二个hack的地方

Java代码  

Class []args = method.getParameterTypes();  
Object []values = new Object[args.length];  
  
//args[0]  
  
for (int i = 0; i < args.length; i++){  
    if(i == args.length-1){  
        values[i] = in.readObject(args[i], ip);  
    }else{  
        values[i] = in.readObject(args[i]);  
    }  
      
}  

我用这个ip地址取代最后一个参数（web服务函数的参数，即远程端调用的函数的参数）。
第三个hack的地方就是 in.readObject(args[i], ip); 这个方法。这个方法是我自己加的，原本只有
in.readObject(args[i]); 这个方法。这个方法就是hessian读取参数值的地方
进去看看

Java代码  

/** 
 * Reads an object from the input stream with an expected type. 
 */  
public Object readObject(Class cl, String ip)  
  throws IOException  
{  
  if (cl == null || cl == Object.class)  
    return readObject();  
    
  int tag = _offset < _length ? (_buffer[_offset++] & 0xff) : read();  
  
  switch (tag) {  
  case 'N':  
    return null;  
  
  case 'M':  
  {  
    String type = readType();  
    Deserializer reader;  
    reader = findSerializerFactory().getObjectDeserializer(type);  
  
    if (cl != reader.getType() && cl.isAssignableFrom(reader.getType()))  
      return reader.readMap(this);  
  
    reader = findSerializerFactory().getDeserializer(cl);  
  
    return reader.readMap(this);  
  }  
  
  case 'O':  
  {  
    return readObjectDefinition(cl);  
  }  
  
  case 'o':  
  {  
    int ref = readInt();  
  
    ObjectDefinition def = (ObjectDefinition) _classDefs.get(ref - 1);  
  
    return readObjectInstance(cl, def);  
  }  
  
  case 'V':  
  {  
    String type = readType();  
    int length = readLength();  
      
    Deserializer reader;  
    reader = findSerializerFactory().getObjectDeserializer(type);  
      
    if (cl != reader.getType() && cl.isAssignableFrom(reader.getType()))  
      return reader.readList(this, length);  
  
    reader = findSerializerFactory().getDeserializer(cl);  
  
    Object v = reader.readList(this, length);  
  
    return v;  
  }  
  
  case 'v':  
  {  
    int ref = readInt();  
    String type = (String) _types.get(ref);  
    int length = readInt();  
      
    Deserializer reader;  
    reader = findSerializerFactory().getObjectDeserializer(type);  
      
    if (cl != reader.getType() && cl.isAssignableFrom(reader.getType()))  
      return reader.readLengthList(this, length);  
  
    reader = findSerializerFactory().getDeserializer(cl);  
  
    Object v = reader.readLengthList(this, length);  
  
    return v;  
  }  
  
  case 'R':  
  {  
    int ref = parseInt();  
  
    return _refs.get(ref);  
  }  
  
  case 'r':  
  {  
    String type = readType();  
    String url = readString();  
  
    return resolveRemote(type, url);  
  }  
  }  
  
  if (tag >= 0)  
    _offset--;  
  
  Object value = findSerializerFactory().getDeserializer(cl).readObject(this);  
  
  if(value instanceof String){  
    value = ip;  
  }  
  return value;  
}  

我重载了这个方法，加入了一个String类型的参数，用来把ip地址传进去，并且最后返回这个值。到了这里，hack的原理大家应该知道了--就是强行修改远程调用端的调用函数里边的最后一个参数的值（规定为String类型），把这个值设为我想要的信息，那么服务端的服务函数就会获得这个值，并且进行后续处理。
剩下的步骤就原封不动的是hessian来处理了，没有需要干涉的地方，你也就能在你的服务端service函数里边获得这个你想要的信息了。

这就是Hessian的一个普通流程，不知道分析和Hack的对不对，我在这里是调试成功了，但是还没彻底测试有没有其它bug。至于跟Spring的结合，待会儿跟帖来说。

转载自：http://www.iteye.com/topic/108611

本文链接：https://blog.csdn.net/yanglinlin/article/details/84764275

原作者删帖不实内容删帖广告或垃圾文章投诉

智能推荐

2024秋季整合Github上最叼的Java教程和实战项目整合成了一个PDF文档，太香-程序员宅基地

文章浏览阅读291次，点赞5次，收藏9次。蚂蚁面试比较重视基础，所以Java那些基本功一定要扎实。蚂蚁的工作环境还是挺赞的，因为我面的是稳定性保障部门，还有许多单独的小组，什么三年1班，很有青春的感觉。面试官基本水平都比较高，基本都P7以上，除了基础还问了不少架构设计方面的问题，收获还是挺大的。经历这次面试我还通过一些渠道发现了需要大厂真实面试主要有：蚂蚁金服、拼多多、阿里云、百度、唯品会、携程、丰巢科技、乐信、软通动力、OPPO、银盛支付、中国平安等初，中级，高级Java面试题集合，附带超详细答案，希望能帮助到大家。

Redis 缓存穿透击穿雪崩_同类型的key固定时间+随机值间,-程序员宅基地

文章浏览阅读96次。Redis 缓存穿透击穿雪崩_同类型的key固定时间+随机值间,

【算法习题】数组中未出现的最小正整数-程序员宅基地

文章浏览阅读1.2k次。题目：给定一个无序整型数组arr，找到数组中未出现的最小正整数。要求时间复杂度为O(N)空间复杂度为O(1)。例如：arr=[-1,2,3,4]。返回1。arr=[1,2,3,4]。返回5。=========================================================分析：这道题要理解最小正整数的意思，最小的正整数就是1，所以考..._最小未出现的正整数

分治算法③-使用分治算法实现二分查找-python_python实现分治法二分搜索从控制台输入-程序员宅基地

文章浏览阅读1k次，点赞3次，收藏6次。如果 target >array[mid] ，令 left=middle+1，继续在数组的后半部分进行搜索;如果 target 判定 left_python实现分治法二分搜索从控制台输入

信息系统项目管理师必背核心考点（二十七）关键路径法（CPM）_关键路径的考点-程序员宅基地

文章浏览阅读1k次。科科过为您带来软考信息系统项目管理师核心重点考点（二十七）关键路径法（CPM），内含思维导图+真题_关键路径的考点

【氧化镓】Ga2O3 MOSFET器件的单SEB机制TCAD研究-程序员宅基地

文章浏览阅读636次，点赞8次，收藏9次。本文是一篇关于氧化镓(Ga2O3)金属氧化物半导体场效应晶体管(MOSFET)在单粒子烧毁(single event burnout, SEB)事件中的机制研究的文章。文章通过使用技术计算机辅助设计(TCAD)模拟来探究侧向耗尽型氧化镓MOSFET设备在SEB中的敏感区域和安全操作电压，并提出了辐射损伤机制。

随便推点

Tensorflow for Java + Spark-Scala分布式机器学习计算框架的应用实践(1)-程序员宅基地

文章浏览阅读810次，点赞10次，收藏12次。说句实话，如果一个打工人不想提升自己，那便没有工作的意义，毕竟大家也没有到养老的年龄。当你的技术在一步步贴近阿里p7水平的时候，毫无疑问你的薪资肯定会涨，同时你能学到更多更深的技术，交结到更厉害的大牛。推荐一份Java架构之路必备的学习笔记，内容相当全面！！！成年人的世界没有容易二字，前段时间刷抖音看到一个程序员连着加班两星期到半夜2点的视频。在这个行业若想要拿高薪除了提高硬实力别无他法。你知道吗？现在有的应届生实习薪资都已经赶超开发5年的程序员了，实习薪资26K，30K，你没有紧迫感吗？

机器学习中训练集、验证集和测试集的作用_机器学习验证集-程序员宅基地

文章浏览阅读6.9w次，点赞29次，收藏131次。通常，在训练有监督的机器学习模型的时候，会将数据划分为训练集、验证集合测试集，划分比例一般为0.6:0.2:0.2。对原始数据进行三个集合的划分，是为了能够选出效果（可以理解为准确率）最好的、泛化能力最佳的模型。训练集（Training set）作用是用来拟合模型，通过设置分类器的参数，训练分类模型。后续结合验证集作用时，会选出同一参数的不同取值，拟合出多个分类器。验证集(Cross Valida..._机器学习验证集

picrust2功能预测-从qiime2安装到数据分析_picrust2功能预测结果怎么看-程序员宅基地

文章浏览阅读1w次，点赞6次，收藏38次。记录一下跌跌撞撞地摸索过程picrust2功能预测参照公众号《宏基因组》刘永鑫的原创：《PICRUSt2：OTU或ASV等16S随便预测宏基因组且数据库增加10倍》https://blog.csdn.net/woodcorpse/article/details/89302863注：命令中 \为断行用，实际上输入命令要去掉，在输入文件路径时没有用此符号断行。虚拟机与qiime2安装参照公众..._picrust2功能预测结果怎么看

C# Winform 窗体美化（二、LayeredSkin 界面库）-程序员宅基地

文章浏览阅读3.6w次，点赞15次，收藏28次。二、LayeredSkin 窗口美化库概况这部分资源是 Winform 美化最多的了，效果还不错，使用时只需引入 LayeredSkin.dll - 696 KB 即可。网上能找到的最后 LayeredSkin 版本应该是 LayeredSkin Demo2014-12-10.zip，之后作者就整合成一个更加强大的商业版界面库（DSkin）了。效果图示例Demo_layeredskin

Kanzi软件开发与Android的关系_kanzi_on_android_3_9_4_setup-程序员宅基地

文章浏览阅读2.8k次，点赞3次，收藏6次。随着Android在汽车领域尤其是在车载娱乐系统方向使用的场景越来越多，Kanzi作为Android提高界面效果、提升界面开发效率的优质小伙伴，Android+Kanzi的组合被越来越多的整车厂和供应商采用。那么这对小伙伴是怎样打交道的呢？这一期就来给大家介绍下。一、Kanzi On Android原理我们先来了解下Kanzi On Android应用的基本知识。从Kanzi的kanzi_engine.jar源码中可以看到，KanziActivity继承自Android的Activity，渲染的Ka_kanzi_on_android_3_9_4_setup

【ChatGLM3】（7）：在autodl上，使用A50显卡，使用LLaMa-Factory开源项目对ChatGLM3进行训练，非常方便的，也方便可以使用多个数据集_chatglm3 训练-程序员宅基地

文章浏览阅读3.4k次，点赞20次，收藏20次。工具还是非常的简单，可以把机构参数进行设置下。主要就是把参数可视化，同时把结果也可视化。非常的方便。进度也可以看到。_chatglm3 训练