Java实现Web的ashx对接ORM

news2024/11/24 14:27:57

之前的介绍已经实现了ORM的主体和Web的调用结构主题，那么这次把Web和LIS.Core的容器和ORM做对接，通过ashx实现的业务类测试调用ORM查询数据。

首先改造容器让传入根地址

package LIS.Core.Context;

import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import java.io.File;
import java.lang.reflect.Type;
import java.net.URL;
import java.net.URLClassLoader;
import java.util.List;
import java.util.HashMap;
import java.util.*;
import java.nio.file.Path;
import java.nio.file.Paths;

//一个迷你版容器，供ORM等控制反转使用
public class ObjectContainer {

    ///用来存类型
    private static List<Class> classList=new ArrayList<Class>();

    ///存类的查找关系
    private static HashMap<String, Integer> classIndexMap = new HashMap<String, Integer>();

    /// <summary>
    /// 按类型返回强类型的对象,一般用接口获得实现类
    /// </summary>
    /// <typeparam name="T">对象类型</typeparam>
    /// <returns>返回的对象</returns>
    public static <T> T GetObject()
    {
        Type type = ObjectContainer.class.getClass().getGenericSuperclass();
        Class c=type.getClass();
        Class<?> parent=c.getSuperclass();
        String cName=c.getName();
        if(classIndexMap.containsKey(cName))
        {
            //创建对象
            Object o = GetObject(cName);
            return (T)o;
        }
        if(parent!=null)
        {
            String parentName=parent.getName();
            if(classIndexMap.containsKey(parentName))
            {
                //创建对象
                Object o = GetObject(parentName);
                return (T)o;
            }
        }
        Class<?> interfaceArr[]=c.getInterfaces();
        if(interfaceArr!=null&&interfaceArr.length>0)
        {
            for(int j=0;j<interfaceArr.length;j++)
            {
                String interfaceName=interfaceArr[j].getName();
                if(classIndexMap.containsKey(interfaceName))
                {
                    //创建对象
                    Object o = GetObject(interfaceName);
                    return (T)o;
                }
            }
        }
        return null;
    }

    /// <summary>
    /// 按名称返回强类型的对象
    /// </summary>
    /// <typeparam name="T">对象类型</typeparam>
    /// <param name="name">对象名称</param>
    /// <returns>返回的对象</returns>
    public static <T> T GetTypeObject(String name)
    {
        Object o=GetObject(name);
        return (T)o;
    }

    /// <summary>
    /// 按名称返回对象
    /// </summary>
    /// <param name="name">对象名称</param>
    /// <returns>返回对象</returns>
    public static Object GetObject(String name)
    {
        if(classIndexMap.containsKey(name))
        {
            try {
            int index=classIndexMap.get(name);
            Class c=classList.get(index);
            //创建对象
            Object o = c.newInstance();
            return o;
            }
            catch (Exception ex)
            {
                ex.printStackTrace();
            }
        }
        return null;
    }


    /// <summary>
    /// 用类型全名和程序集全名获得类型
    /// </summary>
    /// <param name="typeName">类型全名</param>
    /// <param name="assemblyName">程序集名</param>
    /// <returns></returns>
    private static Class GetType(String typeName, String assemblyName,String bashePath)
    {
        try {
            if(bashePath=="")
            {
                //得到根路径
                Class<?> clazz = ObjectContainer.class;
                ClassLoader classLoader = clazz.getClassLoader();
                URL resourceURL1 = classLoader.getResource("");
                bashePath = resourceURL1.getFile();
            }
            //组装成jar包路径
            String jarPath=Paths.get(bashePath,assemblyName+".jar").toString();
            File file = new File(jarPath);
            if (!file.exists()) {
                throw new Exception("未能找到"+jarPath+"的文件");
            }
            //反射得到类型
            //自己生成jar包路径
            URL url = file.toURI().toURL();
            URL[] urls = new URL[]{url};
            //加载程序集
            URLClassLoader loader = new URLClassLoader(urls,ObjectContainer.class.getClassLoader());
            //加载类
            Class c = loader.loadClass(typeName);
            if(c!=null)
            {
                return  c;
            }
            else
            {
                throw new Exception("未能构建类型"+typeName);
            }
        }
        catch (Exception ex)
        {
            ex.printStackTrace();
        }
        return  null;
    }

    /// <summary>
    /// 从根目录的ObjConfig初始化IOC容器，还是按Spring.Net的配置格式
    /// </summary>
    public static void InitIoc(String basePath) {
        try {
            String IocPath ="";
            if(basePath!="")
            {
                IocPath=Paths.get(basePath,"Conf","ObjConfig.xml").toString();
            }
            else
            {
                //得到根路径
                Class<?> clazz = ObjectContainer.class;
                ClassLoader classLoader = clazz.getClassLoader();
                URL resourceURL = classLoader.getResource(Paths.get("Conf","ObjConfig.xml").toString());
                IocPath = resourceURL.getFile();
            }
            //判断配置是否存在
            File file = new File(IocPath);
            if (!file.exists()) {
                System.out.println(IocPath+"文件不存在,请确认!");
                return;
            }
            //解析xml
            DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
            DocumentBuilder builder = factory.newDocumentBuilder();
            Document document = builder.parse(file);
            // 获得根节点
            Element rootElement = document.getDocumentElement();
            // 获得根节点下的所有子节点
            NodeList students = rootElement.getChildNodes();
            for (int i = 0; i < students.getLength(); i++) {
                // 由于节点多种类型，而一般我们需要处理的是元素节点
                Node childNode = students.item(i);
                // 元素节点就是非空的子节点，也就是还有孩子的子节点
                if (childNode.getNodeType() == Node.ELEMENT_NODE) {
                    Element childElement = (Element) childNode;
                    //不是对象配置元素就忽略
                    if(childElement.getNodeName()!= "object")
                    {
                        continue;
                    }
                    //解析类型配置
                    String type=childElement.getAttribute("type");
                    //是否单例
                    String singleton=childElement.getAttribute("singleton");
                    //取对象id
                    String id=childElement.getAttribute("id");
                    //分割类全面和包名
                    String [] arr=type.split(",");
                    //反射得到类型
                    Class c=GetType(arr[0],arr[1],basePath);
                    //添加到类型列表
                    classList.add(c);
                    //存储索引
                    int index=classList.size()-1;
                    Class<?> parent=c.getSuperclass();
                    //有id就存id映射
                    if(id!=null&&id!="")
                    {
                        if(classIndexMap.containsKey(id))
                        {
                            throw new Exception("已经包含了id为:"+id+"的类型");
                        }
                        classIndexMap.put(id,index);
                    }
                    //有父类就存父类映射
                    if(parent!=null)
                    {
                        String parentName=parent.getName();
                        if(!classIndexMap.containsKey(parentName))
                        {
                            classIndexMap.put(parentName,index);
                        }
                    }
                    //得到所有实现的接口
                    Class<?> interfaceArr[]=c.getInterfaces();
                    //循环存接口映射
                    if(interfaceArr!=null&&interfaceArr.length>0)
                    {
                        for(int j=0;j<interfaceArr.length;j++)
                        {
                            String interfaceName=interfaceArr[j].getName();
                            if(!classIndexMap.containsKey(interfaceName)) {
                                classIndexMap.put(interfaceName, index);
                            }
                        }
                    }
                }
            }

        }
        catch (Exception ex) {
            ex.printStackTrace();
        }
    }
}

然后改造Web调用主体，传入地址初始化容器，通过jar包反射调用ashx类

import appcode.IBaseHttpHandler;

import java.io.*;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import java.util.concurrent.ConcurrentHashMap;
import java.net.URL;
import java.net.URLClassLoader;
import java.nio.file.Path;
import java.nio.file.Paths;

import java.util.*;


@javax.servlet.annotation.WebServlet(name = "MianMiddleware")
public class MainMiddleware extends javax.servlet.http.HttpServlet {

    /// <summary>
    /// 缓存路径和类型，允许多线程读一个线程写
    /// </summary>
    private static ConcurrentHashMap<String, Class> hsType = new ConcurrentHashMap<>();

    ///执行post请求
    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        //得到网站根路径
        String basePath = getServletContext().getRealPath("/");
        //尝试执行初始化主逻辑
        MainInit.TryInit(basePath);
        response.setContentType("text/html");
        request.setCharacterEncoding("UTF-8");
        response.setCharacterEncoding("UTF-8");
        String url=request.getRequestURI();
        //解析得到类名
        String className = url.split("\\.")[0];
        PrintWriter writer = response.getWriter();
        //反射得到类型
        Object objDeal = GetObjectByConfString(className,writer,basePath);
        //转换处理接口
        if(objDeal!=null)
        {
            //转换成接口
            appcode.IBaseHttpHandler baseDeal=(appcode.IBaseHttpHandler)objDeal;
            baseDeal.ProcessRequest(request,response);
        }
        else
        {
            Write(writer,"为找到名称为:"+className+"的处理类");
        }
    }

    /// <summary>
    /// 通过配置得当对象
    /// </summary>
    /// <param name="confStr">配置UI/login/ashx/AshDemo</param>
    /// <returns></returns>
    public static Object GetObjectByConfString(String confStr,PrintWriter writer,String basePath) {
        try {
            //取第一部分
            if (confStr.charAt(0) == '/') {
                confStr = confStr.substring(1);
            }
            System.out.println("confStr:"+confStr);
            if (!hsType.containsKey(confStr)) {
                String [] nameArr=confStr.split("/");
                String classFullName = "";
                //类代码全路径
                String classCodePath = basePath;
                for (int i = 1; i < nameArr.length; i++)
                {
                    //类代码文件全名
                    classCodePath = Paths.get(classCodePath, nameArr[i]).toString();
                    //类带命名空间的全名
                    if(classFullName!="")
                    {
                        classFullName += "." + nameArr[i];
                    }
                    else
                    {
                        classFullName = nameArr[i];
                    }
                }
                //类代码地址，后面实现用脚本编译用
                classCodePath = classCodePath + ".java";
                //编译的jar名字
                String clsJarPath = Paths.get(basePath, "BinAshx", classFullName + ".jar").toString();
                System.out.println("加载jar包:"+clsJarPath);
                //自己生成jar包路径
                URL url = new File(clsJarPath).toURI().toURL();
                URL[] urls = new URL[]{url};
                //加载程序集，这里很重要，一定要指定父加载器，否则加载的类和父加载器的类不认为是一个类
                URLClassLoader loader = new URLClassLoader(urls, MainMiddleware.class.getClassLoader());
                ClassLoader  loader1=Thread.currentThread().getContextClassLoader();
                //加载类
                Class c = loader.loadClass(classFullName);
                //先写死，后面执行编译和从jar包反射
                hsType.put(confStr, c);
            }
            Class c = hsType.get(confStr);
            //创建对象
            Object o = c.newInstance();
            return o;
        }
        catch (Exception ex) {
            ex.printStackTrace();
        }
        return null;
    }

    //get直接走post的逻辑
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        doPost(request,response);
    }

    ///输出数据到前台
    private static void Write(PrintWriter writer,String str)
    {
        writer.println(str);
        writer.flush();
        writer.close();
    }

}

然后实现两个测试的ashx

package test.ashx;
import appcode.BaseHttpHandlerNoSession;
import appcode.IBaseHttpHandler;
import LIS.Model.Entity.*;
import LIS.DAL.ORM.EntityManager.EntityManagerImpl;
import java.util.List;
import java.util.HashMap;
import java.util.*;
import LIS.Core.Dto.HashParam;
import com.alibaba.fastjson.*;
//查询数据测试
public class ashGetTableData  extends BaseHttpHandlerNoSession implements IBaseHttpHandler  {
    //查询工作组
    public String QryBTWorkGroup()
    {
        BTWorkGroup species = new BTWorkGroup();
        LIS.DAL.ORM.EntityManager.EntityManagerImpl entry = new EntityManagerImpl();
        HashParam hash = new HashParam();
        List<BTWorkGroup> list = entry.FindAll(species, hash,"",0,0);
        Object json=JSONObject.toJSON(list);
        return json.toString();
    }

    //查询工作小组
    public String QryBTWorkGroupMachine()
    {
        BTWorkGroupMachine loc = new BTWorkGroupMachine();
        LIS.DAL.ORM.EntityManager.EntityManagerImpl entry = new EntityManagerImpl();
        HashParam hash = new HashParam();
        List<BTWorkGroupMachine> list = entry.FindAll(loc, hash,"",0,0);
        Object json=JSONObject.toJSON(list);
        return json.toString();
    }
}


package AshDemo;
import appcode.BaseHttpHandlerNoSession;
import appcode.IBaseHttpHandler;
import LIS.Model.Entity.*;
import LIS.DAL.ORM.EntityManager.EntityManagerImpl;
import java.util.List;
import java.util.HashMap;
import java.util.*;
import LIS.Core.Dto.HashParam;
import com.alibaba.fastjson.*;

public class ashDemo  extends BaseHttpHandlerNoSession implements IBaseHttpHandler  {
    public ashDemo()
    {
        super();
    }

    ///测试
    public String Test()
    {
        return "这是ashDemo返回的文本";
    }

    ///测试
    public String ZLZ()
    {
        return "这是名称为ZLZ的方法返回的文本";
    }

    //查询性别
    public String QrySysFromSpecies()
    {
        BTSpecies species = new BTSpecies();
        LIS.DAL.ORM.EntityManager.EntityManagerImpl entry = new EntityManagerImpl();
        HashParam hash = new HashParam();
        List<BTSpecies> list = entry.FindAll(species, hash,"",0,0);
        Object json=JSONObject.toJSON(list);
        return json.toString();
    }

    //查询科室
    public String QryLocation()
    {
        BTLocation loc = new BTLocation();
        LIS.DAL.ORM.EntityManager.EntityManagerImpl entry = new EntityManagerImpl();
        HashParam hash = new HashParam();
        List<BTLocation> list = entry.FindAll(loc, hash,"",0,0);
        Object json=JSONObject.toJSON(list);
        return json.toString();
    }


}

在这里插入图片描述

在这里插入图片描述

然后运行测试
在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

至此Web调用ashx访问数据库打通了，ORM也在给力小伙伴的努力下快速填充，给力给力

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

测试ORM代码

package com.company;
//import org.apache.commons.configuration.ConfigurationException;
//import org.apache.commons.configuration.PropertiesConfiguration;
import LIS.Core.Dto.HashParam;
import LIS.Core.Dto.OutParam;
import LIS.Core.Dto.OutStatus;
import LIS.DAL.ORM.EntityManager.EntityManagerImpl;
import LIS.Model.Entity.BTSpecies;
import LIS.Model.Entity.SYSForm;
import LIS.Model.Entity.SYSUser;
import org.w3c.dom.*;
import javax.xml.parsers.*;
import java.io.*;
import java.net.URL;
import java.sql.SQLException;
import java.util.List;
import java.util.HashMap;
import java.util.*;
import com.alibaba.fastjson.*;

public class Main {

    public static void main(String[] args) {
        //用容器的配置xml初始化容器
        LIS.Core.Context.ObjectContainer.InitIoc();
        //ORM通过容器取数据库驱动工厂
        LIS.DAL.ORM.EntityManager.EntityManagerImpl orm=new LIS.DAL.ORM.EntityManager.EntityManagerImpl();
        //执行查询测试
        orm.DBSelectTest();
        //测试通过实体得到SQL语句
        orm.InsertSqlTest(new SYSForm());
        orm.InsertSqlTest(new SYSUser());
        //调用ORM的FindAll测试
        HashParam hs = new HashParam();
        hs.Add("Code","QC");
        List<SYSForm> formList=orm.FindAll(new SYSForm(),hs,"RowID desc",-1,-1);
        Object json=JSONObject.toJSON(formList);
        System.out.println("查询的LIST数据:"+json.toString());
        System.out.println("=========================");
        //SaveTest();
        //UpdateTest();
        BatchDB();
        QryTest();
    }

    public static void QryTest()
    {
        BTSpecies species = new BTSpecies();
        LIS.DAL.ORM.EntityManager.EntityManagerImpl entry = new EntityManagerImpl();
        HashParam hash = new HashParam();
        List<BTSpecies> list = entry.FindAll(species, hash,"",0,0);
        for (BTSpecies obj : list)
        {
            String ss = obj.RowID + "\t" + obj.Code + "\t" + obj.CName + "\t" + obj.Pregnant;
            System.out.println(ss);
        }
    }

    public static void UpdateTest()
    {
        BTSpecies species = new BTSpecies();
        species.CName = "测试性别修改";
        species.Code = "D";
        species.STDCode = "CS";
        species.Pregnant = false;
        species.RowID = 23;
        EntityManagerImpl entry = null;
        try
        {
            entry = new EntityManagerImpl();
            if (entry.DBConnection == null) {
                System.out.println("数据库未连接");
                return;
            }
            boolean trans = entry.DBConnection.BeginTransaction();
            if (trans)
            {
                OutParam outParam = new OutParam();
                int row = entry.Update(species,null,outParam,null,null,null);
                if (outParam.Code == OutStatus.ERROR)
                {
                    System.out.println(outParam.Message);
                    entry.DBConnection.RollTransaction();
                    return;
                }
                boolean end = entry.DBConnection.CommitTransaction();
                if (!end)
                {
                    System.out.println("提交事务失败！");
                }
                System.out.println("更新成功数据返回：" + row);
            }
            else
            {
                System.out.println("开启事务失败！");
            }
        }
        catch (Exception ex)
        {
            if (entry != null)
            {
                entry.DBConnection.RollTransaction();
            }
            ex.printStackTrace();
        }
    }

    public static void SaveTest()
    {
        BTSpecies species = new BTSpecies();
        species.CName = "测试性别";
        species.Code = "E";
        species.STDCode = "CS";
        species.Pregnant = true;
        EntityManagerImpl entry = null;
        try
        {
            entry = new EntityManagerImpl();
            if (entry.DBConnection == null) throw new SQLException("数据库未连接");
            boolean trans = entry.DBConnection.BeginTransaction();

            if (trans)
            {
                int row = entry.Save(species);
                boolean end = entry.DBConnection.CommitTransaction();
                if (!end)
                {
                    System.out.println("提交事务失败！");
                }
                System.out.println("保存数据返回：" + row);

            }
            else
            {
                System.out.println("开启事务失败！");
            }
        }
        catch (SQLException ex)
        {
            if (entry != null)
            {
                entry.DBConnection.RollTransaction();
            }
            ex.printStackTrace();
        }
    }

    public static void BatchDB()
    {
        BTSpecies species = new BTSpecies();
        species.CName = "测试性别2121";
        species.Code = "E3";
        species.STDCode = "CS";
        species.Pregnant = false;
        species.RowID = 22;

        EntityManagerImpl entry = null;

        try
        {
            entry = new EntityManagerImpl();
            if (entry.DBConnection == null) throw new SQLException("数据库未连接");
            boolean trans = entry.DBConnection.BeginTransaction();

            if (trans)
            {
                OutParam outRemove = new OutParam();
                int row = entry.Remove(species, null, outRemove, null, null);
                if (outRemove.Code == OutStatus.ERROR)
                {
                    throw new SQLException("删除数据失败");
                }

                System.out.println("删除数据返回：" + row);
                BTSpecies species1 = new BTSpecies();
                species1.RowID = 24;
                species1.Pregnant = true;
                species1.CName = "批量修改的名称--Update";
                species1.HISCode = "BHIS";

                List<String> cols = new ArrayList<String>();
                cols.add("CName");
                cols.add("HISCode");
                cols.add("Pregnant");

                List<String> joins = new ArrayList<String>();
                joins.add("OR");
                joins.add("OR");

                HashParam param = new HashParam();
                param.Add("Code","C");
                param.Add("Code","B");
                param.Add("Code","E");

                OutParam out = new OutParam();

                row = entry.Update(species1, param, out, cols, joins, null);

                if (out.Code == OutStatus.ERROR)
                {
                    throw new SQLException("更新数据失败！" + out.Message);
                }

                boolean end = entry.DBConnection.CommitTransaction();
                if (!end)
                {
                    System.out.println("提交事务失败！");
                }
                System.out.println("更新数据返回：" + row);
                entry.DBConnection.Close();
            }
            else
            {
                System.out.println("开启事务失败！");
            }
        }
        catch (SQLException ex)
        {
            if (entry != null)
            {
                entry.DBConnection.RollTransaction();
            }
            ex.printStackTrace();
        }
        finally {
            if (entry != null && entry.DBConnection != null)
            {
                entry.DBConnection.Close();
            }
        }
    }
}

下一个阶段全面实现ORM的api和实现ashx业务java脚本自动编译jar包到BinAshx目录供Web调用

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1164644.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

单例模式-懒汉式双重锁机制

单例模式-懒汉式双重锁机制

正是因为担心并发问题&#xff0c;才在双重检查锁模式中的synchronized内部进行了再次判断 tnull。 在第一次判断 tnull 之后&#xff0c;当多个线程同时通过这个检查&#xff0c;其中一个线程会获得锁并创建实例。然而&#xff0c;其他线程在此期间可能会继续等待锁释放&…
阅读更多...
ViT Vision Transformer超详细解析，网络构建，可视化，数据预处理，全流程实例教程

ViT Vision Transformer超详细解析，网络构建，可视化，数据预处理，全流程实例教程

关于ViT的分析和教程&#xff0c;网上又虚又空的东西比较多&#xff0c;本文通过一个实例&#xff0c;将ViT全解析。 包括三部分内容&#xff0c;网络构建&#xff1b;orchview.draw_graph 将网络每一层的结构与输入输出可视化&#xff1b;数据预处理。附完整代码 网络构建 …
阅读更多...
【Code Reading】Transformer in vision and video

【Code Reading】Transformer in vision and video

文章目录 1. vit2. Swin-t3. vit_3D4. TimeSformer First&#x1f680;&#x1f680;5. vivit 1. vit 详细解释 在论文的Table1中有给出三个模型&#xff08;Base/ Large/ Huge&#xff09;的参数&#xff0c;在源码中除了有Patch Size为16x16的外还有32x32的。其中的Layers就…
阅读更多...
基于MIMO通信系统的球形译码算法matlab性能仿真,对比PSK检测,SDR检测

基于MIMO通信系统的球形译码算法matlab性能仿真,对比PSK检测,SDR检测

目录 1.算法运行效果图预览 2.算法运行软件版本 3.部分核心程序 4.算法理论概述 5.算法完整程序工程 1.算法运行效果图预览 2.算法运行软件版本 MATLAB2022A 3.部分核心程序 ................................................................ for i1:length(SNR) Bit…
阅读更多...
SpringCloud(六) Nacos配置管理

SpringCloud(六) Nacos配置管理

Nacos除了可以做注册中心,同样可以做配置管理来使用; Nacos做注册中心的使用和注意事项详看:SpringCloud(四) Nacos注册中心-CSDN博客 目录 一, 统一配置管理 1. 在Nacos中添加配置文件 2. 从微服务拉取配置 (1) 引入nacos-config依赖 (2) 添加bootstrap.yaml (3) 读取n…
阅读更多...
相机存储卡被格式化了怎么恢复？数据恢复办法分享！

相机存储卡被格式化了怎么恢复？数据恢复办法分享！

随着时代的发展&#xff0c;相机被越来越多的用户所使用&#xff0c;这也意味着更多的用户面临着相机数据丢失的问题&#xff0c;很多用户在使用相机的过程中&#xff0c;都出现过不小心格式化相机存储卡的情况&#xff0c;里面的数据也将一并消失&#xff0c;相机存储卡被格式…
阅读更多...
Android13充电动画实现

Android13充电动画实现

充电动画 以MTK平台为例&#xff0c;实现充电动画 效果图 修改文件清单 system/vendor/mediatek/proprietary/packages/apps/SystemUI/src/com/android/systemui/charging/BubbleBean.javasystem/vendor/mediatek/proprietary/packages/apps/SystemUI/src/com/android/system…
阅读更多...
2023年【道路运输企业安全生产管理人员】考试资料及道路运输企业安全生产管理人员考试技巧

2023年【道路运输企业安全生产管理人员】考试资料及道路运输企业安全生产管理人员考试技巧

题库来源&#xff1a;安全生产模拟考试一点通公众号小程序 道路运输企业安全生产管理人员考试资料根据新道路运输企业安全生产管理人员考试大纲要求&#xff0c;安全生产模拟考试一点通将道路运输企业安全生产管理人员模拟考试试题进行汇编&#xff0c;组成一套道路运输企业安…
阅读更多...
浅谈新能源汽车充电桩的选型与安装

浅谈新能源汽车充电桩的选型与安装

叶根胜 安科瑞电气股份有限公司 上海嘉定201801 摘要&#xff1a;电动汽车的大力发展和推广是国家为应对日益突出的燃油供需矛盾和环境污染&#xff0c;加强生态环境保护和治理而开发新能源和清洁能源的措施之一&#xff0c;加快了电动汽车的发展。如今&#xff0c;电动汽车已…
阅读更多...
Pure-Pursuit 跟踪双移线 Gazebo 仿真

Pure-Pursuit 跟踪双移线 Gazebo 仿真

Pure-Pursuit 跟踪双移线 Gazebo 仿真 主要参考学习下面的博客和开源项目 自动驾驶规划控制&#xff08;&#xff21;*、pure pursuit、LQR算法&#xff0c;使用c在ubuntu和ros环境下实现&#xff09; https://github.com/NeXTzhao/planning Pure-Pursuit 的理论基础见今年六月…
阅读更多...
如何在 Endless OS 上安装 ONLYOFFICE 桌面编辑器 7.5

如何在 Endless OS 上安装 ONLYOFFICE 桌面编辑器 7.5

ONLYOFFICE 桌面编辑器是一款基于依据 AGPL v.3 许可进行分发的开源办公套件。使用这款应用&#xff0c;您无需保持网络连接状态即可处理存储在计算机上的文档。本指南会向您介绍&#xff0c;如何在 Endless OS 上安装 ONLYOFFICE 桌面编辑器 7.5。 ONLYOFFICE 桌面版是什么 O…
阅读更多...
Ansible中的任务执行控制

Ansible中的任务执行控制

循环 简单循环 {{item}} 迭代变量名称 loop: - value1 - value2 - ... //赋值列表{{item}} //迭代变量名称循环散列或字典列表 - name: create filehosts: host1tasks:- name: file moudleservice:name: "{{ item.name }}"state: "{{…
阅读更多...
实验记录之——git push

实验记录之——git push

平时做开发的时候经常push代码不成功&#xff0c;如下图 经好友传授经验&#xff0c;有如下方法 Win cmd使用Clash&#xff08;端口是7890&#xff09;代理操作&#xff0c;在cmd中输入&#xff1a; set http_proxy127.0.0.1:7890 set https_proxy127.0.0.1:7890Linux export …
阅读更多...
防火墙日志记录和分析

防火墙日志记录和分析

防火墙监控进出网络的流量&#xff0c;并保护部署防火墙的网络免受恶意流量的侵害。它是一个网络安全系统&#xff0c;它根据一些预定义的规则监控传入和传出的流量&#xff0c;它以日志的形式记录有关如何管理流量的信息&#xff0c;日志数据包含流量的源和目标 IP 地址、端口…
阅读更多...
可视化流程编排(Bpmn.js)介绍及实践

可视化流程编排(Bpmn.js)介绍及实践

作者:罗强 为将内部系统打通并规范流程定义&#xff0c;基于统一的平台实现工单自动化流转,从而使用无界山工单系统帮助公司内部人员统一管理和处理来自企业内部提交的工单需求。而在系统中流程编排及节点设计主要是使用bpmn.js实现精细化配置。从而满足各种复杂的业务需求。目…
阅读更多...
MapStruct的用法

MapStruct的用法

提示&#xff1a;文章写完后&#xff0c;目录可以自动生成&#xff0c;如何生成可参考右边的帮助文档 文章目录 前言一、依赖导入二、简单使用2.1、定义转换的接口2.2、创建实体类2.3、测试2.4、底层实现 三、常用的注解3.1、Mapping(target "xxx1",source "x…
阅读更多...
你还在用System.currentTimeMillis()打印代码执行时间？

你还在用System.currentTimeMillis()打印代码执行时间？

文章目录 前言一、开发环境二、使用步骤1. 创建Springboot项目2. 引入hutool3. 使用TimeInterval 总结 前言 Hutool是一个小而全的Java工具类库&#xff0c;里面集成了很多实用的工具类&#xff0c;比如文件、流、加密解密、转码、正则、线程、XML等&#xff0c;通过这些工具类…
阅读更多...
探索 Java 8 中的 Stream 流：构建流的多种方式

探索 Java 8 中的 Stream 流：构建流的多种方式

人嘛&#xff0c;要懂得避嫌… 开篇引入 Java 8引入了Stream流作为一项新的特性&#xff0c;它是用来处理集合数据的一种函数式编程方式。Stream流提供了一种更简洁、高效和易于理解的方法来操作集合数据&#xff0c;同时也能够实现并行处理&#xff0c;以提高性能。 以下是St…
阅读更多...
在 GORM 中定义模型

在 GORM 中定义模型

为实现与数据库的无缝交互而打造有效模型的全面指南 在使用 GORM 进行数据库管理时&#xff0c;定义模型是基础。模型是您的应用程序的面向对象结构与数据库的关系世界之间的桥梁。本文深入探讨了在 GORM 中打造有效模型的艺术&#xff0c;探讨如何创建结构化的 Go 结构体&…
阅读更多...
第十二章，集合类例题

第十二章，集合类例题

例题1 package 例题;import java.util.*;public class 例题 {public static void main(String[] args) {// TODO Auto-generated method stub//实例化集合类对象Collection<String> list new ArrayList<>();//调用方法&#xff0c;向集合添加数据list.add("…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023