Java实现ORM第一个api-FindAll

news2024/11/6 3:11:44

经过几天的业余开发，今天终于到ORM对业务api本身的实现了，首先实现第一个查询的api

老的C#定义如下
在这里插入图片描述

因为Java的泛型不纯，所以无法用只带泛型的方式实现api，对查询类的api做了调整，第一个参数要求传入实体对象
在这里插入图片描述

首先补充基础方法

反射工具类，用来给实体设置属性值

package LIS.Core.Util;

import java.io.File;
import java.lang.reflect.Field;
import java.lang.reflect.Type;
import java.net.URL;
import java.net.URLClassLoader;

//反射工具类
public class ReflectUtil {
    //设置对象指定属性名字的值
    public static void SetObjValue(Object obj,String name,Object val)
    {
        try {
            Class c = obj.getClass();
            //得到列信息
            Field declaredField = c.getDeclaredField(name);
            //布尔的处理
            if(declaredField.getType()==Boolean.class) {
                if(val.toString()=="1")
                {
                    val=Boolean.TRUE;
                }
                else if(val.toString()=="0")
                {
                    val=Boolean.FALSE;
                }
                else
                {
                    val=Boolean.TRUE;
                }
            }
            //布尔的处理
            else if(declaredField.getType()==boolean.class) {
                if(val.toString()=="1")
                {
                    val=true;
                }
                else if(val.toString()=="0")
                {
                    val=false;
                }
                else
                {
                    val=true;
                }
            }
            //布尔的处理
            else if(declaredField.getType()==int.class) {
                if(val==null)
                {
                    val=0;
                }
            }
            declaredField.set(obj, val);
        }
        catch (Exception ex)
        {
            ex.printStackTrace();
        }
    }

    /// <summary>
    /// 用类型全名和程序集全名获得类型
    /// </summary>
    /// <param name="typeName">类型全名</param>
    /// <param name="assemblyName">程序集名</param>
    /// <returns></returns>
    public static Class GetType(String typeName, String assemblyName)
    {
        try {
            //得到根路径
            Class<?> clazz = ReflectUtil.class;
            ClassLoader classLoader = clazz.getClassLoader();
            URL resourceURL1 = classLoader.getResource("");
            String bashePath = resourceURL1.getFile();
            //组装成jar包路径
            String jarPath=bashePath+assemblyName+".jar";
            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);
            //加载类
            Class c = loader.loadClass(typeName);
            if(c!=null)
            {
                return  c;
            }
            else
            {
                throw new Exception("未能构建类型"+typeName);
            }
        }
        catch (Exception ex)
        {
            ex.printStackTrace();
        }
        return  null;
    }
}

HashTable转参数列表工具类，把老的HashTable传参数转换为内部ParaDto

package LIS.Core.Util;
import LIS.Core.Dto.ParamDto;
import java.util.List;
import java.util.HashMap;
import java.util.*;

import java.util.Hashtable;

public class HashToParam {
    //哈希表得到参数列表
    public static List<ParamDto> GetParam(Hashtable hs)
    {
        List<ParamDto> retList=new ArrayList<ParamDto>();
        Enumeration keys = hs.keys();
        while(keys.hasMoreElements()) {
            String str = (String) keys.nextElement();
            ParamDto dto=new ParamDto();
            dto.Key=str;
            dto.Value=hs.get(str);
            retList.add(dto);
        }
        return retList;
    }
}

参数实体，传sql参数用

package LIS.Core.Dto;
//ORM参数对象
public class ParamDto {
    /// <summary>
    /// 关键字段名称
    /// </summary>
    public Object Key;

    /// <summary>
    /// 关键字段值
    /// </summary>
    public Object Value;

    ///构造函数
    public ParamDto()
    {
    }

    //构造函数
    public ParamDto(Object key, Object value)
    {
        this.Key = key;
        this.Value = value;
    }
}

ORM的FindAll实现

package LIS.DAL.ORM.EntityManager;

import LIS.Core.Context.ObjectContainer;

import java.lang.reflect.Type;
import java.sql.*;
import java.util.List;
import java.util.*;
import LIS.Core.Dto.*;

public class EntityManagerImpl implements LIS.DAL.ORM.EntityManager.IEntityManager {
    /// <summary>
    /// 存会话信息
    /// </summary>
    LIS.Model.Bussiness.Sessions Session=null;

    /// <summary>
    /// 开启事务，该方法初始化一个新的事务
    /// </summary>
    public void BeginTransaction()
    {

    }

    /// <summary>
    /// 数据查询
    /// </summary>
    /// <typeparam name="T">实体类型</typeparam>
    /// <param name="model">传入一个空的或者非空的实体对象</param>
    /// <param name="param">参数哈希表，数据库列名称和值的键值对</param>
    /// <param name="orderField">排序字段，如RowID ASC,Name DESC</param>
    /// <param name="pageSize">页面大小。为-1，无条件查询所有数据</param>
    /// <param name="pageIndex">页码。为-1，无条件查询所有数据</param>
    /// <returns>对象集合</returns>
    public <T> List<T> FindAll(T model,Hashtable param, String orderField, int pageSize, int pageIndex)
    {
        List<T> retList = new ArrayList<T>();
        //建立连接
        Connection conn = null;
        //command
        PreparedStatement stmt = null;
        try {
            Class c = model.getClass();

            //转换参数
            List<ParamDto> para=LIS.Core.Util.HashToParam.GetParam(param);
            //得到数据库驱动工厂
            LIS.DAL.ORM.DBUtility.IDbFactory factory= LIS.Core.Context.ObjectContainer.GetTypeObject("LisMianDbFactory");
            //得到表信息
            LIS.DAL.ORM.Common.TableInfo tableInfo = LIS.DAL.ORM.Common.ModelToSqlUtil.GetTypeInfo(model);
            //得到sql语句
            String sql = LIS.DAL.ORM.Common.ModelToSqlUtil.GetSelectSqlByTableInfo(factory, tableInfo, para, null, null, orderField, false);
            //连接串，最后的是数据库名称
            String url = factory.GetConnectionString();
            //用户
            String user = factory.GetUserName();
            //密码
            String password = factory.GetUserPass();

            //加载驱动
            factory.LoadDriver();
            //数据库连接
            conn = DriverManager.getConnection(url,user,password);
            stmt = conn.prepareStatement(sql);
            //设置数据参数
            LIS.DAL.ORM.DBUtility.DBParaUtil.SetDBPara(stmt,para);
            //执行sql得到结果集
            ResultSet rs = stmt.executeQuery();

            // 处理查询结果
            while (rs.next()) {
                //一行数据
                T oneRow = (T) c.newInstance();
                //循环读取列数据放入实体中
                for(int j=0;j<tableInfo.ColList.size();j++)
                {
                    String ColName=tableInfo.ColList.get(j).Name;
                    Object val=rs.getObject(ColName);
                    //设置属性值
                    LIS.Core.Util.ReflectUtil.SetObjValue(oneRow,ColName,val);
                }
                retList.add(oneRow);
            }
            // 关闭 ResultSet、Statement 和 Connection 对象
            rs.close();
        }
        catch (Exception ex)
        {
            ex.printStackTrace();
        }
        finally {
            // 关闭资源
            try {
                if (stmt != null)
                {
                    stmt.close();
                }
            }
            catch (Exception se2) {
            }
            try {
                if (conn != null)
                {
                    conn.close();
                }
            }
            catch (Exception se2) {
            }
        }
        return retList;
    }


    /// <summary>
    /// 查询测试
    /// </summary>
    public void DBSelectTest()
    {
        LIS.DAL.ORM.DBUtility.IDbFactory factory= LIS.Core.Context.ObjectContainer.GetTypeObject("LisMianDbFactory");

        //连接串，最后的是数据库名称
        String url = factory.GetConnectionString();
        //用户
        String user = factory.GetUserName();
        //密码
        String password = factory.GetUserPass();
        //建立连接
        Connection conn = null;
        //command
        PreparedStatement stmt = null;
        try {
            //加载驱动
            factory.LoadDriver();
            conn = DriverManager.getConnection(url,user,password);

            //编译和执行SQL语句,传输SQL参数查询1997-2000行
            String sql = "SELECT * FROM dbo.SYS_Form where \"RowID\">? and \"RowID\"<?;";
            stmt = conn.prepareStatement(sql);
            stmt.setInt(1,1997);
            stmt.setInt(2,2000);
            //结果集
            ResultSet rs = stmt.executeQuery();

            // 处理查询结果
            while (rs.next()) {
                //取列数据
                int RowID = rs.getInt("RowID");
                String CName = rs.getString("CName");
                String Path = rs.getString("Path");
                //输出
                System.out.println(RowID + "\t" + CName + "\t" + Path);
            }

            // 关闭 ResultSet、Statement 和 Connection 对象
            rs.close();
        }
        catch (Exception ex) {
            // 处理 JDBC 异常
            ex.printStackTrace();
        }
        finally {
            // 关闭资源
            try {
                if (stmt != null)
                {
                    stmt.close();
                }
            }
            catch (Exception se2) {
            }
            try {
                if (conn != null)
                {
                    conn.close();
                }
            }
            catch (Exception se2) {
            }
        }
    }

    /**
     * Query data object by primary key ID, mainly used for writing business logic with SQL.
     * The difference between this method and GetById is that it has an internal caching mechanism.
     * @param <T> Entity type
     * @param id Object RowID
     * @return Data object
     */
    public <T> T dolerGet(Object id) {
        T model=null;
        model.getClass();
        //Class<?> type = T.class;
        //String typeName = type.getSimpleName();
        //System.out.println(typeName);
        return null;
    }

    ///测试SQL生成
    public <T> void  InsertSqlTest1()
    {
        try {
            T model=null;
            Class c=model.getClass();
            model=(T)c.newInstance();
            LIS.DAL.ORM.Common.TableInfo tableInfo = LIS.DAL.ORM.Common.ModelToSqlUtil.GetTypeInfo(model);
            LIS.DAL.ORM.DBUtility.IDbFactory factory = LIS.Core.Context.ObjectContainer.GetTypeObject("LisMianDbFactory");
            String sql = LIS.DAL.ORM.Common.ModelToSqlUtil.GetSelectSqlByTableInfo(factory, tableInfo, null, null, null, "", true);
            System.out.println(sql);
        }
        catch (Exception ex)
        {
            ex.printStackTrace();
        }
    }

    ///测试SQL生成
    public <T> void  InsertSqlTest(T model)
    {
        try {
            //Type type = EntityManagerImpl.class.getClass().getGenericSuperclass();
            //Class c = type.getClass();
            //System.out.println(c.getName());
            //System.out.println(model.getClass().getName());
            LIS.DAL.ORM.Common.TableInfo tableInfo = LIS.DAL.ORM.Common.ModelToSqlUtil.GetTypeInfo(model);
            LIS.DAL.ORM.DBUtility.IDbFactory factory = LIS.Core.Context.ObjectContainer.GetTypeObject("LisMianDbFactory");
            String sql = LIS.DAL.ORM.Common.ModelToSqlUtil.GetSelectSqlByTableInfo(factory, tableInfo, null, null, null, "", true);
            System.out.println(sql);
        }
        catch (Exception ex)
        {
            ex.printStackTrace();
        }
    }


    /// <summary>
    /// 保存对象
    /// </summary>
    /// <typeparam name="T">实体类型</typeparam>
    /// <param name="entity">实体对象</param>
    /// <returns>影响行数</returns>
    public <T> int Save(T entity)
    {
        return  0;
    }
}

实体转Sql的工具类

package LIS.DAL.ORM.Common;
import LIS.Core.CustomAttributes.*;
import LIS.Core.Dto.*;
import LIS.Core.Dto.ParamDto;
import java.util.*;
import java.util.List;
import LIS.DAL.ORM.Common.TableInfo;
import LIS.DAL.ORM.DBUtility.IDbFactory;

import java.lang.annotation.Annotation;
import java.lang.reflect.*;
import LIS.DAL.ORM.Common.ColumnInfo;
import LIS.DAL.ORM.Common.TableInfo;
import LIS.Core.Util.ReflectUtil;
import LIS.Core.CustomAttributes.TableAttribute;

//通过实体类型得到SQL的工具类
public class ModelToSqlUtil {
    //通过实体对象得到表信息
    public static TableInfo GetTypeInfo(Object model) {
        if (model == null) {
            return null;
        }
        try {
            //返回的对象
            TableInfo tableInfo = new TableInfo();
            Class c = model.getClass();
            //得到表特性
            Annotation[] annoList = c.getAnnotations();
            if (annoList != null && annoList.length > 0) {
                for (int i = 0; i < annoList.length; i++) {
                    //表特性
                    if (annoList[i] instanceof TableAttribute) {
                        tableInfo.TableInfo = (TableAttribute) annoList[i];
                    }
                    //唯一特性
                    else {
                        tableInfo.UniqueList.add((UniqueAttribute) annoList[i]);
                    }
                }
            }
            //得到列信息
            Field[] declaredFields = c.getDeclaredFields();
            for (int i = 0; i < declaredFields.length; i++) {
                LIS.DAL.ORM.Common.ColumnInfo col = new LIS.DAL.ORM.Common.ColumnInfo();
                FrekeyAttribute fk = declaredFields[i].getAnnotation(FrekeyAttribute.class);
                col.FkInfo = fk;
                col.Name = declaredFields[i].getName();
                col.ColType = declaredFields[i].getType();
                col.Value = declaredFields[i].get(model);
                tableInfo.ColList.add(col);
            }

            return tableInfo;
        } catch (Exception ex) {
            ex.printStackTrace();
        }
        return null;
    }

    //通过表信息和参数列表组装查询SQL
    //factory:驱动工厂
    //tableInfo:表信息
    //para:参数
    //operList:参数对应的操作符列表
    //linkList:多个参数之间连接的操作符 and or这种
    //orderBySql:Order By的SQL语句
    //IsFk:是否组装外键查询的SQL
    public static String GetSelectSqlByTableInfo(IDbFactory factory,TableInfo tableInfo, List<ParamDto> para,List<String> operList,List<String> linkList, String orderBySql,Boolean IsFk)
    {
        StringBuilder sb=new StringBuilder();
        sb.append("select ");
        //是否含有序号列
        boolean HasSequence=false;
        boolean HasSeqNum=false;
        //组装查询列
        for(int i=0;i<tableInfo.ColList.size();i++)
        {
            //存列名
            String columnName = tableInfo.ColList.get(i).Name;
            if(columnName=="Sequence")
            {
                HasSequence=true;
            }
            else if(columnName=="SeqNum")
            {
                HasSeqNum=true;
            }
            //组装查询列
            if(i==0)
            {
                sb.append(factory.DealPropertyName(columnName));
            }
            else
            {
                sb.append(","+factory.DealPropertyName(columnName));
            }
            //组装外键查询信息
            if(IsFk==true&&tableInfo.ColList.get(i).FkInfo!=null) {
                FrekeyAttribute fkAttr=tableInfo.ColList.get(i).FkInfo;
                String refTableName=factory.DealTableName(GetTableName(ReflectUtil.GetType("LIS.Model.Entity." + fkAttr.Name(), "LIS.Model")));
                sb.append("," + "(select " + factory.DealPropertyName(fkAttr.AssociaField()) + " from " + refTableName + " where ti." + factory.DealPropertyName(columnName) + "=" + refTableName + "." + factory.DealPropertyName(fkAttr.RefColumnName()) + ") as " + factory.DealPropertyName(columnName + "_" + fkAttr.Name() + "_" + fkAttr.AssociaField()));
                //如果有拉取字段1，查询拉取字段
                if (fkAttr.AssociaField1() != "")
                {
                    sb.append("," + "(select " + factory.DealPropertyName(fkAttr.AssociaField1()) + " from " + refTableName + " where ti." + factory.DealPropertyName(columnName) + "=" + refTableName + "." + factory.DealPropertyName(fkAttr.RefColumnName()) + ") as " + factory.DealPropertyName(columnName + "_" + fkAttr.Name() + "_" + fkAttr.AssociaField1()));
                }
                //如果有拉取字段2，查询拉取字段
                if (fkAttr.AssociaField2() != "")
                {
                    sb.append("," + "(select " + factory.DealPropertyName(fkAttr.AssociaField2()) + " from " + refTableName + " where ti." + factory.DealPropertyName(columnName) + "=" + refTableName + "." + factory.DealPropertyName(fkAttr.RefColumnName()) + ") as " + factory.DealPropertyName(columnName + "_" + fkAttr.Name() + "_" + fkAttr.AssociaField2()));
                }
            }
        }
        sb.append(" from " + factory.DealTableName(tableInfo.TableInfo.Name()) + " ti ");

        //组装查询参数
        if(para!=null&&para.size()>0)
        {
            sb.append(" where ");
            for(int i=0;i<para.size();i++)
            {
                String oper="=";
                if(operList!=null&&operList.size()>i)
                {
                    oper=operList.get(i);
                }
                String link="and";
                if(operList!=null&&operList.size()>i-1)
                {
                    link=operList.get(i-1);
                }
                if(i==0) {
                    sb.append(factory.DealPropertyName(para.get(i).Key.toString()) + oper + factory.DealSqlPara(para.get(i).Key.toString()));
                }
                else
                {
                    sb.append(" "+link+" "+factory.DealPropertyName(para.get(i).Key.toString()) + oper + factory.DealSqlPara(para.get(i).Key.toString()));
                }
            }
        }

        //存组装的排序sql
        String strSort = "";
        //如果传入了排序字段，组装排序语句
        if (orderBySql != null && orderBySql.length() > 0)
        {
            //用来存处理的排序串
            String dealStr = "";
            //先分割多个排序条件
            String[] strList = orderBySql.split(",");
            for (int m = 0; m < strList.length; m++)
            {
                //分开多个排序条件
                if (m > 0)
                {
                    dealStr += ",";
                }
                //分开字段名称和升降序
                String[] strSubList = strList[m].split(" ");
                //处理字段名称
                dealStr += factory.DealPropertyName(strSubList[0]);
                //组装处理的串
                for (int n = 1; n < strSubList.length; n++)
                {
                    dealStr += " " + strSubList[n];
                }
            }
            //组装排序串
            strSort = " Order By " + dealStr;
        }
        else
        {
            if (HasSequence)
            {
                strSort = " Order By " + factory.DealPropertyName("Sequence") + " ASC";
            }
            else if (HasSeqNum)
            {
                strSort = " Order By " + factory.DealPropertyName("SeqNum") + " ASC";
            }
            else
            {
                strSort = "";
            }
        }
        sb.append(strSort);
        return sb.toString();
    }

    //通过实体类型得到实体表名称
    private static String GetTableName(Class c)
    {
        //存表名
        String strTableName = "";
        //得到表特性
        TableAttribute tableInfo = null;
        //得到表特性
        Annotation[] annoList = c.getAnnotations();
        if (annoList != null && annoList.length > 0) {
            for (int i = 0; i < annoList.length; i++) {
                //表特性
                if (annoList[i] instanceof TableAttribute) {
                    tableInfo = (TableAttribute) annoList[i];
                    strTableName=tableInfo.Name();
                    break;
                }
            }
        }
        return strTableName;
    }
}

数据库驱动工厂，增加得到用户名和密码的方法接口

package LIS.DAL.ORM.DBUtility;

//数据驱动层接口，ORM基于此加载驱动和执行SQL
public interface IDbFactory {
    //得到数据库类型
    String GetStrDbType();

    //得到数据库连接串
    String GetConnectionString();

    //得到数据库用户名
    String GetUserName();

    //得到数据库密码
    String GetUserPass();

    //得到返回查询的RowID的SQL语句
    String GetReturnRowIDSql();

    //处理表名称，用来适配不同数据库间的属性命名差异
    String DealTableName(String tableName);

    //处理属性名字
    String DealPropertyName(String propertyName);

    //DealSqlPara
    String DealSqlPara(String propertyName);

    //加载驱动
    void LoadDriver();
}

调用测试，这里引入了阿里的对象转JSON库，fastjson

package com.company;
//import org.apache.commons.configuration.ConfigurationException;
//import org.apache.commons.configuration.PropertiesConfiguration;
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.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测试
        Hashtable hs=new Hashtable();
        hs.put("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());
    }
}

测试结果
在这里插入图片描述

把依赖的不稳定搞定后就快多了，轻松加愉快，哈哈。不过发现泛型不如C#强，方法不支持默认参数，尤其是方法不支持默认参数这个真不像一个现代语言，总体使用语法特性方面和工程依赖方面和IDE体验和C#比差多了，末日黄花喽，官方闭源，语法古老

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

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

相关文章

android——自定义控件(编辑框)、悬浮窗

android——自定义控件(编辑框)、悬浮窗

一、自定义编辑框 效果图&#xff1a; 主要的代码为&#xff1a; class EditLayout JvmOverloads constructor(context: Context, attrs: AttributeSet? null, defStyleAttr: Int 0 ) : ConstraintLayout(context, attrs, defStyleAttr) {private var editTitle: Stringpr…
阅读更多...
Android12 启动页适配

Android12 启动页适配

印象中&#xff0c;在2022年末接到了一个针对Android12启动页适配的需求&#xff0c;当时也使用了一些适配方案&#xff0c;也写了一个Demo&#xff0c;但是最终没有付诸适配行动&#xff1b;当然并不是适配失败&#xff0c;而是根据官方适配方案适配后太丑了… 1024纪念文章&a…
阅读更多...
Java中的CAS简述

Java中的CAS简述

目录 1、CAS是什么 2、CAS的生活化例子 3、Java中的atomic包 4、unsafe类 5、CAS的缺点及解决方案 小结 1、CAS是什么 CAS&#xff08;Compare and Swap&#xff09;是一种并发编程中的原子操作&#xff0c;用于实现多线程环境下的无锁同步。它是一种乐观锁的实现方式&a…
阅读更多...
分布式限流:Redis

分布式限流:Redis

目录 1:如何实现分布式限流 2:限流的几种类别 2.1:固定窗口限流 2.2:滑动窗口限流 2.3:漏桶限流 2.4:令牌桶限流 3:实现分布式限流:Redis 3.1:引入Redisson的依赖包 3.2:初始化Redisson 3.3:创建Redisson的限流类 1:如何实现分布式限流 1:把统计用户的使用频率等这些…
阅读更多...
Springcloud介绍

Springcloud介绍

1.基本介绍 Spring Cloud是一系列框架的有序集合。它利用Spring Boot的开发便利性巧妙地简化了分布式系统基础设施的开发&#xff0c;如服务发现注册、配置中心、消息总线、负载均衡、断路器、数据监控等&#xff0c;都可以用Spring Boot的开发风格做到一键启动和部署。Spring …
阅读更多...
欧拉图和哈密顿图

欧拉图和哈密顿图

欧拉图 在连通图G中&#xff0c;经过G的每条边一次且仅一次的通路&#xff0c;称为欧拉通路若欧拉通路为回路&#xff0c;则称为欧拉回路含有欧拉回路的图称为欧拉图有欧拉通路则G可以一笔画出有欧拉回路则G是连通的且无奇点&#xff08;欧拉图无奇点&#xff09; 哈密顿图 …
阅读更多...
2023了，是时候使用pnpm了！

2023了，是时候使用pnpm了！

2023了&#xff0c;是时候使用pnpm了&#xff01; Excerpt 2023了&#xff0c;是时候使用pnpm了&#xff01; 什么是pnpm pnpm代表performant npm&#xff08;高性能的npm&#xff09;&#xff0c;同npm和Yarn&#xff0c;都属于Javascript包管理安装工具&#xff0c;它较npm和…
阅读更多...
树与二叉树（考研版）

树与二叉树（考研版）

文章目录 树与二叉树树的基本概念结点、树属性的描述树的性质 二叉树的概念二叉树的性质二叉树的构建二叉树的遍历先序遍历中序遍历后序遍历层次遍历 递归算法和非递归算法的转换源代码 线索二叉树二叉树的线索化线索二叉树 找前驱/后继 树和森林树的存储 树与二叉树的应用哈夫…
阅读更多...
交换机基础（四）：MSTP负载均衡配置案例

交换机基础（四）：MSTP负载均衡配置案例

如图所示是某个企业内部核心网络的结构图&#xff0c;目前企业中有20个VLAN, 编号为VLAN1&#xff5e;VLAN20, 为了确保内部网络的可靠性&#xff0c;使用 了冗余链路和MSTP 协议。为了能更好地利用网络资源和带宽&#xff0c;现管理员希望通过配置MSTP 的负载均衡实现网络带宽…
阅读更多...
【proteus】8086 写一个汇编程序并调试

【proteus】8086 写一个汇编程序并调试

参考书籍&#xff1a;微机原理与接口技术——基于8086和Proteus仿真&#xff08;第3版&#xff09;p103-105&#xff0c;p119-122. 参考程序是p70&#xff0c;例4-1 在上一篇的基础上&#xff1a; 创建项目和汇编文件 写一个汇编程序并编译 双击8086的元件图&#xff1a; …
阅读更多...
2.1 向量与线性方程组

2.1 向量与线性方程组

一、行图像与列图像 线性代数的中心问题是求解线性方程组。线性的意思是这些方程的未知数是一次的&#xff0c;即每个未知数只会乘数字&#xff0c;而不会出现 x x x 与 y y y 相乘的项。下面是一个由两个未知数组成的方程组&#xff1a; 两个方程 两个未知数 { x − 2 y 1…
阅读更多...
Django学习笔记——文件上传（界面还怪好看得嘞）

Django学习笔记——文件上传（界面还怪好看得嘞）

定义文件上传函数 #文件上页面 def uploadFileIndex(request):return render(request, "uploadFile.html")#文件上传接口 def uploadFile(request):if request.method POST and request.FILES[file]:uploaded_file request.FILES[file]fs FileSystemStorage()# 选…
阅读更多...
螺旋矩阵[中等]

螺旋矩阵[中等]

优质博文&#xff1a;IT-BLOG-CN 一、题目 给你一个m行n列的矩阵matrix&#xff0c;请按照顺时针螺旋顺序&#xff0c;返回矩阵中的所有元素。 示例 1&#xff1a; 输入&#xff1a;matrix [[1,2,3],[4,5,6],[7,8,9]] 输出&#xff1a;[1,2,3,6,9,8,7,4,5] 示例 2&#xf…
阅读更多...
vue如何使用冻结对象提升代码效率及其原理解析

vue如何使用冻结对象提升代码效率及其原理解析

先给大家伙整个实际工作中一定会碰到的问题 如下vue dome ,它的代码非常简单功能也1非常简单,就是一个按钮,点击后会显示有多少条数据 来看看源码, html部分就是一个按钮绑定了一个loadData事件,然后在p标签内展示了这个myData这个数据的长度 <template><div id&quo…
阅读更多...
Txt病毒

Txt病毒

一.txt病毒原理 利用翻转字符串的方法 混淆伪装 &#xff08;jpg 、doc、ppt 等&#xff09; &#xff08;1&#xff09;更改程序图标 &#xff08;2&#xff09;将程序重命名 readtxt.exe 鼠标放到 read 与 txt 中间 设置格式为 RLO // 这个“RLO”是一个转义字符&#xf…
阅读更多...
交互式 Web 应用 0 基础入门

交互式 Web 应用 0 基础入门

初探 Gradio&#xff1a;轻松构建交互式 Web 应用 文章目录 初探 Gradio&#xff1a;轻松构建交互式 Web 应用Why Gradio?安装 Gradio创建交互式界面1. gr.Interface2. gr.Blocks 强大的组件库输入输出组件控制组件布局组件 示例交互式数据可视化多组件同时&#xff08;嵌套&a…
阅读更多...
Netty框架详解

Netty框架详解

一、Netty简介 Netty是一款基于Java NIO的网络编程、高性能、异步事件驱动的网络应用框架。它的设计目标是提供简单易用、高性能、可扩展的网络编程框架。 二、Netty主要特点 高并发&#xff1a;Netty使用异步的、非阻塞的I/O模型&#xff0c;通过事件驱动的方式处理网络操作…
阅读更多...
回归预测 | MATLAB实现BO-LSTM贝叶斯优化长短期神经网络多输入单输出回归预测

回归预测 | MATLAB实现BO-LSTM贝叶斯优化长短期神经网络多输入单输出回归预测

回归预测 | MATLAB实现BO-LSTM贝叶斯优化长短期神经网络多输入单输出回归预测 目录 回归预测 | MATLAB实现BO-LSTM贝叶斯优化长短期神经网络多输入单输出回归预测效果一览基本介绍模型搭建程序设计参考资料 效果一览 基本介绍 MATLAB实现BO-LSTM贝叶斯优化长短期神经网络多输入…
阅读更多...
潮流玩具演绎城市文化，泡泡玛特入选2023“上海礼物”

潮流玩具演绎城市文化，泡泡玛特入选2023“上海礼物”

每一座城市都有其独特的文化氛围和历史背景&#xff0c;“城市礼物”承载着地域特色、文化内涵和人文精神&#xff0c;不断复制和传递着城市文化。近年来&#xff0c;上海市文旅局会同有关各方&#xff0c;从旅游商品的研发设计、品牌塑造、展售渠道等方面&#xff0c;创建“上…
阅读更多...
【软件教程】如何用C++交叉编译出能在Android运行的ELF程序或so动态库

【软件教程】如何用C++交叉编译出能在Android运行的ELF程序或so动态库

一、配置NDK交叉编译平台 1. 打开Android的官方ndk下载链接https://developer.android.com/ndk/downloads?hlzh-cn&#xff0c;下载windows 64位ndk环境包。 2. 解压后将具有以下文件的路径加入到系统环境变量。 3. 配置好环境变量&#xff0c;如下图所示&#xff0c;Path中存…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023