自定义orm，快速完成增删改查

最新推荐文章于 2024-01-01 20:00:00 发布
最新推荐文章于 2024-01-01 20:00:00 发布
阅读量141 收藏
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44945027/article/details/124186910
版权

自定义orm


父类 

package com.tlzn.tkwl.usercenter.service;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.tlzn.tkwl.entity.result.CommonResult;
import com.tlzn.tkwl.entity.result.saveorupdate.RowCheck;
import com.tlzn.tkwl.entity.result.saveorupdate.SaveOrUpdateResult;

import com.tlzn.tkwl.util.RedisUtil;
import com.tlzn.tkwl.util.StringUtil;
import com.tlzn.tkwl.util.ReflectUtil;
import org.springframework.http.ResponseEntity;
import org.springframework.web.client.RestTemplate;

import java.lang.reflect.Field;
import java.net.URLEncoder;
import java.util.*;

public abstract class BaseService {


    ObjectMapper objectMapper = new ObjectMapper();

    protected abstract RowCheck getRowCheckResult(Object object);
    protected abstract List<String> getLogicIdFieldList();


    public static final String CURDURL = "http://curd-service/";
    /**
     * 添加
     * @param module
     * @param datasouce
     * @param type
     * @param jsonData
     * @return
     * @throws Exception
     */
    protected String save( RestTemplate restTemplate,String module,String datasouce,String pass,String addr,Integer port,Class<?> type,String jsonData) throws Exception{
        Object object = objectMapper.readValue(jsonData, type);
        SaveOrUpdateResult saveOrUpdateResult = new SaveOrUpdateResult();
        RowCheck rowCheck = getRowCheckResult(object);
        if(rowCheck.getColumnMessageMap().size() > 0){
            rowCheck.setCheck(false);
            saveOrUpdateResult.setRowCheck(rowCheck);
            return objectMapper.writeValueAsString(saveOrUpdateResult);
        }

        String sql = "SELECT COUNT(1) as count  FROM " + type.getSimpleName() + " WHERE ";
        List<String> logicIdFieldList = getLogicIdFieldList();
        for(int i=0;i<logicIdFieldList.size();i++){
            String field = logicIdFieldList.get(i);
            if(i==0)
                sql += field +  " = ? ";
            else
                sql += " and "+field +  " = ? ";
        }
        Map<String,String> dataMap = new LinkedHashMap<>();

        for(int i=0;i<logicIdFieldList.size();i++) {
            Object value =  ReflectUtil.getFieldValue(object,logicIdFieldList.get(i));
            String name =object.getClass().getDeclaredField(logicIdFieldList.get(i)).getType().getName();
            Object types  =  name.substring(name.lastIndexOf(".")+1);;  //获取字段类型
            dataMap.put(i+"_"+types,String.valueOf(value));
        }

        String url = CURDURL+"/curd/ijsondata/selectBySql?module="+module+"&datasource="+datasouce+"&sql="+sql+"&jsonData="+ URLEncoder.encode(objectMapper.writeValueAsString(dataMap),"utf-8");
        ResponseEntity<CommonResult> responseEntity =  restTemplate.getForEntity(url,CommonResult.class);
        CommonResult commonResult = responseEntity.getBody();
        List<Map> results = new ArrayList<>();
        if (commonResult.getData() instanceof ArrayList<?>) {
            for (Object o : (List<?>) commonResult.getData()) {
                results.add(Map.class.cast(o));
            }
            results.get(0).get("count");
        }
        if((int)results.get(0).get("count")> 0){
            rowCheck.getRowMessageList().add("逻辑主键重复");
            rowCheck.setCheck(false);
            saveOrUpdateResult.setRowCheck(rowCheck);
            return objectMapper.writeValueAsString(saveOrUpdateResult);
        }

//        String insertSql = RedisUtil.getTable_Insert(addr,port,pass,type);
//        System.out.println(insertSql);
//        Map<String,String> insertMap =  RedisUtil.getSqlParamMap(addr,port,pass,object);


        String insertSql = "INSERT INTO `tkwl_usercenter`.`usercenter_user`(`db_id`, `db_mobilePhone`, `db_password`, `db_id_username`) VALUES (?,?,?,?);";
        Map<String,String> insertMap = new LinkedHashMap<>();
        insertMap.put("0_String",ReflectUtil.getStringFieldValue(object,"db_id"));
        insertMap.put("1_String",ReflectUtil.getStringFieldValue(object,"db_mobilePhone"));
        insertMap.put("2_String",ReflectUtil.getStringFieldValue(object,"db_password"));
        insertMap.put("3_String",ReflectUtil.getStringFieldValue(object,"db_id_username"));


        String inserturl = CURDURL+"/curd/ijsondata/updateSql?module="+module+"&datasource="+datasouce+"&sql="+insertSql+"&jsonData="+
                                                                    URLEncoder.encode(objectMapper.writeValueAsString(insertMap),"utf-8");
        ResponseEntity<CommonResult> cresponseEntity =  restTemplate.getForEntity(inserturl,CommonResult.class);
        CommonResult cResult = cresponseEntity.getBody();
        if(cResult.isSuccess()){
            RedisUtil.setTableData(addr,port,pass,object);
            return objectMapper.writeValueAsString(saveOrUpdateResult);
        }
        else{
            saveOrUpdateResult.setSuccess(false);
            saveOrUpdateResult.setMessage(commonResult.getMessage());
            return objectMapper.writeValueAsString(saveOrUpdateResult);
        }
    }

    /**
     * 修改
     * @param module
     * @param datasouce
     * @param type
     * @param jsonData
     * @return
     * @throws Exception
     */
    protected String updateById( RestTemplate restTemplate,String module,String datasouce,String pass,String addr,Integer port,Class<?> type,String jsonData) throws Exception{
        Object object = objectMapper.readValue(jsonData, type);
        SaveOrUpdateResult saveOrUpdateResult = new SaveOrUpdateResult();
        RowCheck rowCheck = getRowCheckResult(object);
        if(rowCheck.getColumnMessageMap().size() > 0){
            rowCheck.setCheck(false);
            saveOrUpdateResult.setRowCheck(rowCheck);
            return objectMapper.writeValueAsString(saveOrUpdateResult);
        }
        String sql = "SELECT COUNT(1) as count  FROM " + type.getSimpleName() + " WHERE ";
        List<String> logicIdFieldList = getLogicIdFieldList();
        for(int i=0;i<logicIdFieldList.size();i++){
            String field = logicIdFieldList.get(i);
            if(i==0)
                sql += field +  " = ? ";
            else
                sql += " and "+field +  " = ? ";
        }
        Map<String,String> dataMap = new LinkedHashMap<>();

        for(int i=0;i<logicIdFieldList.size();i++) {
            Object value =  ReflectUtil.getFieldValue(object,logicIdFieldList.get(i));
            String name =object.getClass().getDeclaredField(logicIdFieldList.get(i)).getType().getName();
            Object types  =  name.substring(name.lastIndexOf(".")+1);;  //获取字段类型
            dataMap.put(i+"_"+types,String.valueOf(value));
        }

        String url = CURDURL+"/curd/ijsondata/selectBySql?module="+module+"&datasource="+datasouce+"&sql="+sql+
                "&jsonData="+ URLEncoder.encode(objectMapper.writeValueAsString(dataMap),"utf-8");
        ResponseEntity<CommonResult> responseEntity =  restTemplate.getForEntity(url,CommonResult.class);
        CommonResult commonResult = responseEntity.getBody();
        List<Map> results = new ArrayList<>();
        if (commonResult.getData() instanceof ArrayList<?>) {
            for (Object o : (List<?>) commonResult.getData()) {
                results.add(Map.class.cast(o));
            }
            results.get(0).get("count");
        }
        if((int)results.get(0).get("count")> 1){
            rowCheck.getRowMessageList().add("逻辑主键重复");
            rowCheck.setCheck(false);
            saveOrUpdateResult.setRowCheck(rowCheck);
            return objectMapper.writeValueAsString(saveOrUpdateResult);
        }


//        String updSql = RedisUtil.getTable_Update(addr,port,pass,type);
//        Map<String,String> updateMap = RedisUtil.getSqlParamMap(addr,port,pass,object);
        String updSql = "UPDATE usercenter_user SET db_mobilePhone = ?, db_id_username = ? WHERE db_id = ?";
        Map<String,String> updateMap = new LinkedHashMap<>();

        updateMap.put("0_String",ReflectUtil.getStringFieldValue(object,"db_mobilePhone"));
        updateMap.put("1_String",ReflectUtil.getStringFieldValue(object,"db_id_username"));
        updateMap.put("2_String",ReflectUtil.getStringFieldValue(object,"db_id"));


        String updurl = CURDURL+"/curd/ijsondata/updateSql?module="+module+"&datasource="+datasouce+"&sql="+updSql+"&jsonData="+
                URLEncoder.encode(objectMapper.writeValueAsString(updateMap),"utf-8");
        ResponseEntity<CommonResult> cresponseEntity =  restTemplate.getForEntity(updurl,CommonResult.class);
        CommonResult cResult = cresponseEntity.getBody();
        if(cResult.isSuccess()){
            RedisUtil.setTableData(addr,port,pass,object);
            return objectMapper.writeValueAsString(saveOrUpdateResult);
        }
        else{
            saveOrUpdateResult.setSuccess(false);
            saveOrUpdateResult.setMessage(commonResult.getMessage());
            return objectMapper.writeValueAsString(saveOrUpdateResult);
        }
    }


    /**
     * 删除
     * @param module
     * @param datasouce
     * @param jsonData
     * @return
     * @throws Exception
     */
    protected String deleteById( RestTemplate restTemplate,String module,String datasouce,String pass,String addr,Integer port,Class<?> type,String jsonData) throws Exception{

        SaveOrUpdateResult saveOrUpdateResult = new SaveOrUpdateResult();
        if(StringUtil.isEmpty(jsonData)){
            RowCheck rowCheck = new RowCheck();
            rowCheck.setCheck(false);
            saveOrUpdateResult.setRowCheck(rowCheck);
            rowCheck.getColumnMessageMap().put("db_id","id不能为空");
            return objectMapper.writeValueAsString(saveOrUpdateResult);
        }
        String delsql = "DELETE FROM " + type.getSimpleName() + " WHERE db_id = ? " ;
        Map<String,String> dataMap = new LinkedHashMap<>();
        dataMap.put("0_String",jsonData);


        String url = CURDURL+"/curd/ijsondata/updateSql?module="+module+"&datasource="+datasouce+"&sql="+delsql+"&jsonData="+ URLEncoder.encode(objectMapper.writeValueAsString(dataMap),"utf-8");
        ResponseEntity<CommonResult> responseEntity =  restTemplate.getForEntity(url,CommonResult.class);
        CommonResult commonResult = responseEntity.getBody();
        if(commonResult.isSuccess()){
            RedisUtil.delTableData(addr,port,pass,type,jsonData);
            return objectMapper.writeValueAsString(saveOrUpdateResult);
        }else{
            saveOrUpdateResult.setSuccess(false);
            saveOrUpdateResult.setMessage(commonResult.getMessage());
            return objectMapper.writeValueAsString(saveOrUpdateResult);
        }

    }

    /**
     * 查看一条详情
     * @param module
     * @param datasouce
     * @param jsonData
     * @return
     * @throws Exception
     */
    protected String selectById( RestTemplate restTemplate,String module,String datasouce,String pass,String addr,Integer port,Class<?> type,String jsonData) throws Exception{


        String sql = "SELECT * FROM " + type.getSimpleName() + " WHERE db_id = ? ";
        Map<String,String> dataMap = new LinkedHashMap<>();
        dataMap.put("0_String",jsonData);

        String url = CURDURL+"/curd/ijsondata/selectBySql?module="+module+"&datasource="+datasouce+"&sql="+sql+"&jsonData="+ URLEncoder.encode(objectMapper.writeValueAsString(dataMap),"utf-8");
        ResponseEntity<CommonResult> responseEntity =  restTemplate.getForEntity(url,CommonResult.class);
        CommonResult commonResult = responseEntity.getBody();

        if(commonResult.isSuccess()){
            return objectMapper.writeValueAsString(commonResult);
        }
        else{
            commonResult.setSuccess(false);
            commonResult.setMessage(commonResult.getMessage());
            return objectMapper.writeValueAsString(commonResult);
        }

    }

    /**
     * 删除多条
     * @param module
     * @param datasouce
     * @param jsonData
     * @return
     * @throws Exception
     */
    protected String deleteList( RestTemplate restTemplate,String module,String datasouce,String pass,String addr,Integer port,Class<?> type,String jsonData) throws Exception{


        String sql = "  delete  from  " + type.getSimpleName() + "  where  db_id    = ? " ;

        List<String> list= Arrays.asList(jsonData.split(","));
        List<Object[]>  sList = new LinkedList<>();
        for( String s:list){
            List<String >a = new LinkedList<>();
            a.add(s);
            sList.add(a.toArray());
        }

        JSONArray array= JSONArray.parseArray(JSON.toJSONString(sList));
        Map<String,Object> dataMap = new LinkedHashMap<>();
        dataMap.put("0_String",objectMapper.writeValueAsString(array));
        String url = CURDURL+"/curd/ijsondata/updateSql?module="+module+"&datasource="+datasouce+"&sql="+sql+"&jsonData="+
                                                    URLEncoder.encode(objectMapper.writeValueAsString(dataMap),"utf-8");
        ResponseEntity<CommonResult> responseEntity =  restTemplate.getForEntity(url,CommonResult.class);
        CommonResult commonResult = responseEntity.getBody();

        if(commonResult.isSuccess()){

            //删除多条
            RedisUtil.delMultiTableData(addr,port,pass,type,list);
            return objectMapper.writeValueAsString(commonResult);
        }
        else{
            commonResult.setSuccess(false);
            commonResult.setMessage(commonResult.getMessage());
            return objectMapper.writeValueAsString(commonResult);
        }
    }

    /**
     * 按条件查询所有
     * @param restTemplate
     * @param module
     * @param datasouce
     * @return
     * @throws Exception
     */
    protected String selectByCondition( RestTemplate restTemplate, String module, String datasouce, String pass,String addr,Integer port,Class<?> type, String jsonData) throws Exception{

        String sql = "SELECT * FROM " + type.getSimpleName() + "  where 1= 1 ";
        Map<String,Object> dataMap = new LinkedHashMap<>();


        if(!StringUtil.isEmpty(jsonData)){

            Object object = objectMapper.readValue(jsonData, type);
            Field[] feilds = object.getClass().getDeclaredFields();
            Integer ui_currentPage=0;
            Integer Ui_pageSize=0;
            for(Field field:feilds){
                field.setAccessible(true);
                String name  = field.getName();
                String types = field.getType().toString();
                String fieldtype = types.substring(types.lastIndexOf(".")+1);
                Object value = field.get(object);
                if(value!=null&&name.startsWith("db")){
                    sql+=" and "+name+" = ? ";
                    dataMap.put(dataMap.size()+"_"+fieldtype,value);
                }
                if("ui_currentPage".equals(value)){
                    ui_currentPage = Integer.valueOf((String) value);
                }
                if("Ui_pageSize".equals(value)){
                    Ui_pageSize = Integer.valueOf((String) value);
                }
            }
            if(ui_currentPage!=0&&Ui_pageSize!=0){
                sql+="  limit "+(ui_currentPage-1)*Ui_pageSize+" , "+Ui_pageSize;
            }

        }

        String url = CURDURL+"/curd/ijsondata/selectBySql?module="+module+"&datasource="+datasouce+"&sql="+sql+"&jsonData="+ URLEncoder.encode(objectMapper.writeValueAsString(dataMap),"utf-8");
        ResponseEntity<CommonResult> responseEntity =  restTemplate.getForEntity(url,CommonResult.class);
        CommonResult commonResult = responseEntity.getBody();
        if(commonResult.isSuccess()){
            return objectMapper.writeValueAsString(commonResult);
        }
        else{
            commonResult.setSuccess(false);
            commonResult.setMessage(commonResult.getMessage());
            return objectMapper.writeValueAsString(commonResult);
        }
    }


    /**
     * 查询count
     * @param restTemplate
     * @param module
     * @param datasouce

     * @return
     * @throws Exception
     */
    protected String selectCountByCondition(RestTemplate restTemplate,String module,String datasouce,String pass,String addr,Integer port,Class<?> type,String jsonData) throws Exception{

        String sql = "SELECT count(*) as count FROM  " + type.getSimpleName() + "  where 1= 1 ";
        Map<String,Object> dataMap = new LinkedHashMap<>();
        if(!StringUtil.isEmpty(jsonData)){
            //1 通过object获取实体类
            Object object = objectMapper.readValue(jsonData, type);
            //获取实体类中的对象数组，遍历数组获取参数进行判断是否为空，不为空的时候作为参数遍历到查询语句中
            Field[] feilds = object.getClass().getDeclaredFields();
            for(Field field:feilds){
                field.setAccessible(true);
                String name  = field.getName();
                String types = field.getType().toString();
                String fieldtype = types.substring(types.lastIndexOf(".")+1);
                Object value = field.get(object);
                if(value!=null&&name.startsWith("db")){
                    sql+=" and "+name+" = ? ";
                    dataMap.put(dataMap.size()+"_"+fieldtype,value);
                }
            }
        }
        String url = CURDURL+"/curd/ijsondata/selectBySql?module="+module+"&datasource="+datasouce+"&sql="+sql+"&jsonData="+ URLEncoder.encode(objectMapper.writeValueAsString(dataMap),"utf-8");
        ResponseEntity<CommonResult> responseEntity =  restTemplate.getForEntity(url,CommonResult.class);
        CommonResult commonResult = responseEntity.getBody();
        if(commonResult.isSuccess()){
            List<Map> results = new ArrayList<>();
            if (commonResult.getData() instanceof ArrayList<?>) {
                for (Object o : (List<?>) commonResult.getData()) {
                    results.add(Map.class.cast(o));
                }
                results.get(0).get("count");
            }
            commonResult.setData(results.get(0).get("count"));
            return objectMapper.writeValueAsString(commonResult);
        }
        else{
            commonResult.setSuccess(false);
            commonResult.setMessage(commonResult.getMessage());
            return objectMapper.writeValueAsString(commonResult);
        }

    }


}

子类

package com.tlzn.tkwl.usercenter.service;

import com.fasterxml.jackson.databind.ObjectMapper;

import com.tlzn.tkwl.entity.result.CommonResult;
import com.tlzn.tkwl.entity.result.saveorupdate.RowCheck;
import com.tlzn.tkwl.entity.usercenter.Usercenter_User;
import com.tlzn.tkwl.interfaces.usercenter.IUserService;
import com.tlzn.tkwl.usercenter.context.UsercenterContext;
import com.tlzn.tkwl.util.StringUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

import java.util.*;

@RestController
@RequestMapping("/usercenter/iuser")
public class UserService extends BaseService implements IUserService {


    @Autowired
    RestTemplate restTemplate;

    @Autowired
    ApplicationContext applicationContext;

    @Autowired
    UsercenterContext usercenterContext;


    ObjectMapper objectMapper = new ObjectMapper();

    @RequestMapping(value = "/getLoginUser")
    public String getLoginUser(String token) throws Exception {
        CommonResult commonResult = new CommonResult();
        return objectMapper.writeValueAsString(commonResult);
    }

    /**
     * @param object
     * @return
     */
    protected RowCheck getRowCheckResult(Object object) {

        RowCheck rowCheck = new RowCheck();
        Usercenter_User usercenter_User = (Usercenter_User)object;
        if(StringUtil.isEmpty(usercenter_User.getDb_id_username())){
            rowCheck.getColumnMessageMap().put("db_id_username","姓名不能为空");
        }
        if(StringUtil.isEmpty(usercenter_User.getDb_mobilePhone())){
            rowCheck.getColumnMessageMap().put("db_mobilePhone","手机号不能为空");
        }
        return rowCheck;
    }

    @Override
    protected List<String> getLogicIdFieldList() {
        ArrayList arrayList = new ArrayList();
        arrayList.add("db_mobilePhone");
        return arrayList;
    }


    @RequestMapping(value = "/save")
    public String save(@RequestParam(value="token") String token, @RequestParam(value="jsonData") String jsonData) throws Exception {
        return super.save(restTemplate,usercenterContext.getModule(),usercenterContext.getDatasouce(),usercenterContext.getRedisServerPass(),usercenterContext.getRedisServerAddr(),usercenterContext.getRedisServerPort(),Usercenter_User.class,jsonData);
    }


    @RequestMapping(value = "/updateById")
    public String updateById(@RequestParam(value="token") String token, @RequestParam(value="jsonData") String jsonData) throws Exception {
        return super.updateById(restTemplate,usercenterContext.getModule(),usercenterContext.getDatasouce(),usercenterContext.getRedisServerPass(),usercenterContext.getRedisServerAddr(),usercenterContext.getRedisServerPort(),Usercenter_User.class,jsonData);
    }


    @RequestMapping(value = "/deleteById")
    public String deleteById(String token, String id) throws Exception {
        return super.deleteById(restTemplate,usercenterContext.getModule(),usercenterContext.getDatasouce(),usercenterContext.getRedisServerPass(),usercenterContext.getRedisServerAddr(),usercenterContext.getRedisServerPort(),Usercenter_User.class,id);
    }

    @RequestMapping(value = "/selectById")
    public String selectById(String token, String id) throws Exception {
        return super.selectById(restTemplate,usercenterContext.getModule(),usercenterContext.getDatasouce(),usercenterContext.getRedisServerPass(),usercenterContext.getRedisServerAddr(),usercenterContext.getRedisServerPort(),Usercenter_User.class,id);
    }

    @RequestMapping(value = "/deleteList")
    public String deleteList(@RequestParam(value="token") String token, @RequestParam(value="idList")  String idList) throws Exception {
        return super.deleteList(restTemplate,usercenterContext.getModule(),usercenterContext.getDatasouce(),usercenterContext.getRedisServerPass(),usercenterContext.getRedisServerAddr(),usercenterContext.getRedisServerPort(),Usercenter_User.class,idList);
    }


    @RequestMapping(value = "/selectByCondition")
    public String selectByCondition(String token, @RequestParam(value="jsonData",required = false) String jsonData) throws Exception {
        return super.selectByCondition(restTemplate,usercenterContext.getModule(),usercenterContext.getDatasouce(),usercenterContext.getRedisServerPass(),usercenterContext.getRedisServerAddr(),usercenterContext.getRedisServerPort(),Usercenter_User.class,jsonData);
    }


    @RequestMapping(value = "/selectCountByCondition")
    public String selectCountByCondition(@RequestParam(value="token") String token, @RequestParam(value="jsonData",required = false) String jsonData) throws Exception {
        return super.selectCountByCondition(restTemplate,usercenterContext.getModule(),usercenterContext.getDatasouce(),usercenterContext.getRedisServerPass(),usercenterContext.getRedisServerAddr(),usercenterContext.getRedisServerPort(),Usercenter_User.class,jsonData);

    }

    public String updatePassword(String token, String jsonData) throws Exception {
        return null;
    }


}


配置类
package com.tlzn.tkwl.usercenter.config;


import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.client.ClientHttpRequestFactory;
import org.springframework.http.client.SimpleClientHttpRequestFactory;
import org.springframework.web.client.RestTemplate;

/**
 * RestTemplate配置模板
 *
 * @author like
 */
@Configuration
public class RestTemplateConfig {

    @Bean
    @LoadBalanced
    public RestTemplate restTemplate(ClientHttpRequestFactory simpleClientHttpRequestFactory) {
        return new RestTemplate(simpleClientHttpRequestFactory);
    }

    @Bean
    public ClientHttpRequestFactory simpleClientHttpRequestFactory() {
        SimpleClientHttpRequestFactory factory = new SimpleClientHttpRequestFactory();
        factory.setReadTimeout(5000);//单位为ms
        factory.setConnectTimeout(5000);//单位为ms
        return factory;
    }

}
风雨风
关注
自定义ORM框架
qq_37803406的博客
11-22 338
什么是ORM ORM:Object-Relation-Mapping，也就是对象关系映射，是一种程序设计思想，mybatis就是ORM的一种实现方式，简单来说就是将数据库中查询出的数据映射到对应的实体中。 自定义ORM框架 在jdbc编程中，我们获取到resultSet集后会遍历结果集中的数据，然后通过resultSet.getString(列数或者参数名称)，resultSet.getLong(…)获取值，这样很不方便，因为每次获取到结果都需要自己遍历获取值，程序开发的时间和成本会增加很多，所以有没有一
Python + Flask ORM实现增删改查
Python+大数据+数据分析+自动化+Vue组件开发
06-14 636
1. 背景介绍SQLAlchemy 以 ORM 为核心基础提供可选对象关系映射能力。(1). ORM 提供一个附加的配置层，允许用户自定义的 Python 类进行对象关系映射，通过 session 会话与数据库进行交互。(2). ORM 扩展了核心级别的 SQL 表达式语言，允许按照用户定义的对象组合和调用 SQL 查询。(3). Flask-SQLAlchemy 使用起来非常有趣，对于基本应用十分容易使用，并且对于大型项目易于扩展。(4). 常见情况下对于只有一个 Flask 应用，所有您需要做的
自定义orm字段
weixin_30354675的博客
08-09 131
class MyCharField(models.Field): def __init__(self,max_length,*args,**kwargs): self.max_length = max_length super().__init__(max_length=max_length,*args,**kwargs) ...
自定义一个简单的ORM框架
xiaotai1234的博客
12-14 272
自定义一个简单的ORM框架 一、概述 二、MiniORM框架的结构设计 三、MiniORM框架的代码实现 四、MiniORM框架的测试使用
自定义一个简单的 ORM 框架
kai46385076的专栏
06-24 946
自定义一个简单的 ORM 框架 前面我们通过跟踪源码的方式剖析了Hibernate 和MyBatis 两个框架是如何应用 ORM 思想的，接下来我们自己定义一个简单的 ORM 框架（名为 MiniORM），希望能通过这种方式让大家亲自零距离的去应用一下 ORM。 4.1MiniORM 框架的结构设计 1.第一层为配置层： miniORM.cfg.xml 是框架的核心配置文件，主要用来设置数据库...
自定义框架（一）—— ORM 框架
Jsundoku的博客
03-09 307
文章目录一、ORM 框架1、ORM 框架概念2、自定义框架案例 一、ORM 框架 1、ORM 框架概念 （1）O（对象）：表示程序中的对象 （2）R（关系）：表示关系型数据库 （3）M（模型）：将java中的对象和关系型数据中的数据进行一一映射（类与表进行映射，属性与字段进行映射），在此模型的基础上可以用面向对象的方式操作数据库 2、自定义框架案例 （1）配置 jdbc.xml 文件，里面包括 d...
c#自定义orm链接sqlite数据库增删改查
10-11
本项目“c#自定义ORM链接SQLite数据库增删改查”是基于Dapper库进行扩展，通过Dapper-Plus进一步封装，以实现对SQLite数据库的自动化SQL生成和执行，简化了开发中的数据操作流程。 首先，Dapper是一个轻量级的ORM库...
BootStrapTable实现增删改查
03-07
在MVC（Model-View-Controller）架构中，结合C#后端，BootstrapTable可以实现数据的增删改查操作，提供用户友好的界面和高效的后台处理。 1. **BootstrapTable的基本结构** BootstrapTable的核心是HTML的`<table>`...
C# .net mvc 三层架构 增删改查
09-29
3. **数据访问层（Data Access Layer）**：负责与数据库进行交互，完成数据的增删改查操作。在ASP.NET MVC中，可以使用Entity Framework这样的ORM（对象关系映射）工具，简化数据库操作。这部分通常包括数据上下文类...
springboot增删改查
06-19
在IT行业中，SpringBoot是一个非常...通过简单的配置和代码，我们能够快速实现增删改查功能，极大地提高了开发效率。在实际项目中，还可以根据需求进行自定义查询、事务管理等高级操作，使得数据库操作更加灵活和高效。
自定义Orm框架的实现
05-30
该项目是一个Hibernate框架的简单实现，里面通过Jdk5.0的Annotation实现从对象到数据库之间的映射, 功能类似于小型的Hibernate框架
自定义封装ORM框架
weixin_45715405的博客
09-17 192
import pymysql from pymysql.cursors import DictCursor class Mysql: def __init__(self): db = pymysql.connect(host="127.0.0.1", user='root', password="1213556247", database="Blog", port=3306) self.cursor = db.cursor(DictCursor) # 封
自定义ORM：Python元类教程带你实现轻松数据库操作！
最新发布
涛哥聊Python
01-01 1352
首先，需要定义一个元类，让它负责创建映射类。这个元类需要继承自type类，并重写__new__方法。# 创建映射类的代码将在这里编写通过使用 Python 的元类，可以编写一个简单的 ORM 框架，使得数据库操作更具面向对象的特性。虽然本文中的 ORM 框架非常简单，但它展示了 ORM 技术的基本概念和实现方式。在实际项目中，可以使用成熟的 ORM 库，如 SQLAlchemy，来简化数据库操作，并提高生产力。希望本文能帮助大家理解 ORM 的基本原理和 Python 中元类的使用。
python之自定义ORM数据库框架
坐板凳上敲代码
08-07 595
import pymysql from pymysql.cursors import DictCursor class MySql: # 创建数据库之间的连接 def __init__(self): self.conn = pymysql.connect( host='120.77.87.135', port=3306, user='uatfulluser', password='3yd8f2Hs6w%-xz4L4hKx:3
ORM自定义学习框架
weixin_59519801的博客
09-27 341
ORM自定义框架学习
Mybatis二次深度学习整理——自定义ORM框架
Burnup_110的博客
05-16 356
前言 第二次重复整理Mybatis相关内容，这次相对于上一次的整理会更加的深入，而不仅仅是局限于API的使用上面，当然API的使用也会温习一下，因为距离上次系统整理已经过去一段时间了，有些不常用的内容也有些忘记了。 这次在开始之前首先就整理一下ORM框架的通用体系的一个思路，也就是这篇自定义ORM框架的由来了，这里先声明一下这篇博客主要是为了整理ORM框架的思路，并不是为了开发一个成熟的ORM框架，当然开发一个成熟的ORM框架，我还远远不够格，这也不应该是一个人的工作量。 先说一下加下来涉及的前置知识：
c#ORM框架，自定义语法
飞向架构师
12-23 639
前言 这是我第一次写技术博客，对语言和思路的组织都将是一次升华和洗礼，也希望能在这里结识到更多的朋友，一起学习，一起进步。代码或思路上有什么不对或需要改进的地方请您一定要告知我，万分感谢大家！！！。 本次分享的ORM框架我取名为：OVLite。 为什么要自己开发ORM框架 C#的ORM框架还是有蛮多的，那为什么还要自己开发呢？我认为呢： 不要只学会用，这是知其然不知其所以然的表现； 不要光看不练...
自定义轻量级ORM，MxDaoManager
灵神翁的博客
07-19 212
自定义轻量级ORM，MxDaoManager 前段时间看到了ORM，了解到 ORM是对象关系映射（英语：(Object Relational Mapping，简称ORM，或O/RM，或O/R mapping），是一种程序技术，用于实现面向对象编程语言里不同类型系统的数据之间的转换 [1] 。从效果上说，它其实是创建了一个可在编程语言里使用的--“虚拟对象数据库”。简单点说就是 讲对象的操作装换...
小白成长之路一之自定义ORM框架
wukun_hbb的博客
08-10 121
这里写自定义目录标题欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 欢迎使用Ma...
Django ORM教程：数据库增删改查操作
在完成数据库模型和迁移之后，可以使用Django提供的管理接口或自定义视图进行数据的增删改查操作。例如，创建一个新的书籍记录可以通过创建`Book`类的实例并调用`save()`方法实现： ```python book = Book(name='...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值