Spring自带的持久层模板类：JdbcTemplate+Spring框架声明式事务管理实战

news2024/10/5 16:25:47

模板技术

Spring框架中提供了很多模板类来简化编程，使用模板类编写程序会变的简单

持久层模板JdbcTemplate

在这里插入图片描述
在这里插入图片描述

JdbcTemplate是什么

JDBCTemplate是Spring Framework中的一个核心类，用于简化JDBC（Java数据库连接）代码的编写。它提供了一种更简单、更干净的方式来执行数据库操作，同时抽象了许多常见的数据库任务，如连接管理、异常处理和资源释放。使用JDBCTemplate，开发人员可以更专注于业务逻辑，而不必担心底层数据库操作的细节。

JDBCTemplate和Mybatis的区别

1. JDBCTemplate相当于Spring框架自带的Mybatis的弱化版，mybatis支持声明式事务管理，JDBCTemplate则不支持；

  1. mybatis是一种ORM模型，JDBCTemplate则是对连接池的直接封装，本质上是纯SQL；

  2. mybatis由于实体关系映射，实际的性能会比JDBCTemplate低一些，但是更加灵活

参考文章：
【Java 进阶篇】深入了解JDBCTemplate：简化Java数据库操作

弃用MyBatis！我们最终选择了 JDBCTemplate！

JdbcTemplate实战

0. maven依赖

<dependencies>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.0.2.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>commons-logging</groupId>
        <artifactId>commons-logging</artifactId>
        <version>1.2</version>
    </dependency>
    <dependency>
        <groupId>log4j</groupId>
        <artifactId>log4j</artifactId>
        <version>1.2.12</version>
    </dependency>
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-test</artifactId>
        <version>5.0.2.RELEASE</version>
    </dependency>
    
    <dependency>
        <groupId>aopalliance</groupId>
        <artifactId>aopalliance</artifactId>
        <version>1.0</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-aspects</artifactId>
        <version>5.0.2.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjweaver</artifactId>
        <version>1.8.13</version>
    </dependency>
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>5.1.6</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-jdbc</artifactId>
        <version>5.0.2.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-tx</artifactId>
        <version>5.0.2.RELEASE</version>
    </dependency>
  </dependencies>

1. JdbcTemplate相比于原生的DataSource的优势：简写代码

1.1 连接池DataSource代码实例

这是原生的连接池DataSource

@Repository("carDao")
public class CarDaoImpl implements CarDao{

    @Autowired
    private DataSource dataSource;

    public List<Car> findAll() {
        Connection conn=null;
        PreparedStatement stmt = null;
        ResultSet rs = null;

        List<Car> carList=new ArrayList<Car>();

        //2.获取连接对象
        try{
            conn = dataSource.getConnection();
            //3.编写sql
            String sql = "select * from car";
            //4.获取执行sql的stmt对象
            stmt=conn.prepareStatement(sql);
            //5.执行sql
            rs = stmt.executeQuery();
            //6.遍历结果集
            while(rs.next()){
                //实体类  account的实体类
                Car car = new Car();
                car.setId(rs.getInt("id"));
                car.setCarName(rs.getString("car_name"));
                car.setSize(rs.getInt("size"));
                car.setColor(rs.getString("color"));
                // 存储
                carList.add(car);
            }
            //7.关闭
            conn.close();
            stmt.close();
            rs.close();
        }catch (Exception e){
            e.printStackTrace();
        }
        System.out.println("持久层：操作数据库保存订单");
        return  carList;
    }

获取连接，创建执行对象，编写sql，执行sql，遍历sql执行结果，关闭资源一步都不能少

1.2 new方式创建JdbcTemplate

先创建连接池对象，然后再创建JdbcTemplate对象

    /**
     * 使用new对象方式完成
     */
    public void test(){
        // 创建连接池对象，Spring框架内置了连接池对象
        DriverManagerDataSource dataSource = new DriverManagerDataSource();
        // 设置4个参数
        dataSource.setDriverClassName("com.mysql.jdbc.Driver");
        dataSource.setUrl("jdbc:mysql:///spring_db");
        dataSource.setUsername("root");
        dataSource.setPassword("root");
        
        // 提供模板，创建对象
        JdbcTemplate template = new JdbcTemplate(dataSource);
        // 完成数据的增删改查
        template.update("insert into account values (null,?,?)","熊大",1000);
    }
1.3 控制反转，依赖注入的方式创建JdbcTemplate的bean对象（使用Spring框架来管理模板类）

先创建连接池dataSource的bean对象，再将这个bean对象依赖注入JdbcTemplate的bean对象中

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="
                http://www.springframework.org/schema/beans
                http://www.springframework.org/schema/beans/spring-beans.xsd
                http://www.springframework.org/schema/context
                http://www.springframework.org/schema/context/spring-context.xsd
                http://www.springframework.org/schema/aop
                http://www.springframework.org/schema/aop/spring-aop.xsd">

    <!--配置连接池-->
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver" />
        <property name="url" value="jdbc:mysql:///spring_db" />
        <property name="username" value="root" />
        <property name="password" value="root" />
    </bean>

    <!--配置jdbc模板-->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource" />
    </bean>

</beans>

使用时直接autowired即可

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(value = "classpath:applicationContext_jdbc.xml")
public class Demo1_1 {

    @Autowired
    private JdbcTemplate jdbcTemplate;

    /**
     * 测试的方式
     */
    @Test
    public void run1(){
        jdbcTemplate.update("insert into account values (null,?,?)","熊二",500);
    }

}

2. JdbcTemplate的多种导入方式

2.1 一般的三种方式

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="
                http://www.springframework.org/schema/beans
                http://www.springframework.org/schema/beans/spring-beans.xsd
                http://www.springframework.org/schema/context
                http://www.springframework.org/schema/context/spring-context.xsd
                http://www.springframework.org/schema/aop
                http://www.springframework.org/schema/aop/spring-aop.xsd">

    <!--导入DataSource的bean对象或者JdbcTemplate的bean对象到bean容器中-->

    <!--1. 导入DataSource的bean对象-->
    <!--1.1 导入Spring框架内置的连接池-->
    <bean id="dataSource11" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.cj.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql:///mybatis_demo"/>
        <property name="username" value="root"/>
        <property name="password" value="980708"/>
    </bean>

    <!--1.2 导入使用开源连接池druid-->
    <bean id="dataSource12" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="com.mysql.cj.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql:///mybatis_demo"/>
        <property name="username" value="root"/>
        <property name="password" value="980708"/>
    </bean>

    <!--
        PropertyPlaceholderConfigurer是PlaceholderConfigurerSupport的
    一个子类，用来解析${…} 占位符的，可以使用setLocation和setProperties
    设置系统属性和环境变量。-->
    <!--1.3.1 加载属性的文件，进而解析${…}占位符-->
    <bean id="placeholderConfigurer" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
        <property name="location" value="classpath:druid.properties"/>
    </bean>
    <!--1.3.2 第二种写法：使用提供标签的方式-->
    <context:property-placeholder location="classpath:druid.properties"/>
    <!--1.3 使用加载属性的文件配置druid连接池-->
    <bean id="dataSource13" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="${jdbc.driverClassName}"/>
        <property name="url" value="${jdbc.url}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
    </bean>

    <!--2.1 使用模板，Spring框架内置的连接池-->
    <bean id="jdbcTemplate1" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource11"/>
    </bean>

    <!--2.2 使用模板，开源连接池druid配置jdbc模板-->
    <bean id="jdbcTemplate2" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource12"/>
    </bean>

    <!--2.3 使用模板，开源连接池druid的配置文件加载jdbc模板-->
    <bean id="jdbcTemplate3" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource13"/>
    </bean>
</beans>

导入连接池对象的方式有多种，所以注入dataSource给JdbcTemplate对象时的方式也就有许多种

最推荐的还是读取.properties文件/.yml文件的方式，最为灵活

jdbc.driverClassName=com.mysql.cj.jdbc.Driver
jdbc.url=jdbc:mysql:///mybatis_demo?serverTimezone=UTC
jdbc.username=root
jdbc.password=980708

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="
                http://www.springframework.org/schema/beans
                http://www.springframework.org/schema/beans/spring-beans.xsd
                http://www.springframework.org/schema/context
                http://www.springframework.org/schema/context/spring-context.xsd
                http://www.springframework.org/schema/aop
                http://www.springframework.org/schema/aop/spring-aop.xsd">

<!--1.3.1 加载属性的文件，进而解析${…}占位符-->
    <bean id="placeholderConfigurer" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
        <property name="location" value="classpath:druid.properties"/>
    </bean>
    <!--1.3.2 第二种写法：使用提供标签的方式-->
    <context:property-placeholder location="classpath:druid.properties"/>
    <!--1.3 使用加载属性的文件配置druid连接池-->
    <bean id="dataSource13" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="${jdbc.driverClassName}"/>
        <property name="url" value="${jdbc.url}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
    </bean>

<!--2.3 使用模板，开源连接池druid的配置文件加载jdbc模板-->
    <bean id="jdbcTemplate3" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource13"/>
    </bean>
</beans>

2.2 简写的形式

 <!--配置dao1-->
    <bean id="accountDao" class="com.qcby.mySpring04.mapper.impl.AccountDaoImpl">
        <property name="jdbcTemplate" ref="jdbcTemplate"/>
    </bean>

    <!--2. Dao的第二种使用方式-->
    <!--区别在于：
    1. 不需要导入jdbcTemplate的bean对象；
    2. dao的bean对象依赖注入从jdbcTemplate对象改为dataSource，
    但是需要daoImpl继承JdbcDaoSupport类
    -->

    <!--配置service-->
    <bean id="accountDao2" class="com.qcby.mySpring04.mapper.impl.AccountDaoImpl2">
        <property name="dataSource" ref="dataSource"/>
    </bean>

我们可以发现，第二种形式的dao不需要注入JdbcTemplate，而是直接注入dataSource即可，但是DaoImpl的实现稍有不同

import org.springframework.jdbc.core.support.JdbcDaoSupport;

public class AccountDaoImpl2 extends JdbcDaoSupport implements AccountDao {

    @Override
    public void outMoney(String out, double money) {
        this.getJdbcTemplate().update("update account set money = money - ? where name = ?",
                money, out);
    }

    @Override
    public void inMoney(String in, double money) {
        this.getJdbcTemplate().update("update account set money = money - ? where name = ?",
                money, in);

    }
}

需要额外继承JdbcDaoSupport父类

3. JdbcTemplate可以直接与Spring自带的事务管理集成

相比于正常的AOP，两个都是Spring的亲儿子，所以可以少写很多代码，比如AOP配置类不用写

PlatformTransactionManager接口是平台事务管理器。该接口有具体的实现类，根据不同的持久层框架，需要选择不同的实现类！
接口方法如下：
void commit(TransactionStatus status)
void rollback(TransactionStatus status)

  1. 如果使用的Spring的JDBC模板或者MyBatis框架，需要选择DataSourceTransactionManager实现类

  2. 如果使用的是Hibernate的框架，需要选择HibernateTransactionManager实现类

3.1 xml文件配置Spring框架声明式事务管理

不需要我们自己写切面类，也不需要我们自己写增强的方法，Spring帮我们做好了

JdbcTemplate模板，dataSource，还有dao和service的bean导入略

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="
                http://www.springframework.org/schema/beans
                http://www.springframework.org/schema/beans/spring-beans.xsd
                http://www.springframework.org/schema/context
                http://www.springframework.org/schema/context/spring-context.xsd
                http://www.springframework.org/schema/aop
                http://www.springframework.org/schema/aop/spring-aop.xsd
                http://www.springframework.org/schema/tx
                http://www.springframework.org/schema/tx/spring-tx.xsd">


    <!--配置平台事务管理器-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource" />
    </bean>

    <!--Spring自带的事务切面通知管理-->
    <!--配置事务的通知（没有自己编写切面类，通知方法也不是自己编写，Spring框架提供的）-->
    <tx:advice id="txAdvice" transaction-manager="transactionManager">
        <tx:attributes>
            <!--对pay进行增强，设置隔离级别，传播行为，超时的时间-->
            <tx:method name="pay" isolation="DEFAULT" propagation="REQUIRED" />
            <tx:method name="find*" read-only="true" />
        </tx:attributes>
    </tx:advice>


    <!--配置AOP的增强-->
    <aop:config>
        <!--Spring框架提供系统通知，使用advisor标签-->
        <aop:advisor advice-ref="txAdvice"
                     pointcut="execution( * com.qcby.*.service.impl.*ServiceImpl.*(..))" />
    </aop:config>

    <import resource="ApplicationContext_jdbc.xml"/>
</beans>

3.2 半注解的配置Spring框架声明式事务管理

<!--配置平台事务管理器-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource" />
    </bean>

<!--开启事务注解的支持-->
    <tx:annotation-driven transaction-manager="transactionManager" />

@Transactional可以加在类上，也可以加在方法上

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Isolation;
import org.springframework.transaction.annotation.Transactional;

@Transactional(isolation = Isolation.DEFAULT, propagation = Propagation.REQUIRED, timeout = 10)
@Service
public class AccountServiceImpl implements AccountService {


    @Autowired
    private AccountDao accountDao;

    public void setAccountDao(AccountDao accountDao) {
        this.accountDao = accountDao;
    }

    /**
     * 转账方法
     *
     * @param out   付款人
     * @param in    收款人
     * @param money 金额
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public void pay(String out, String in, double money) {
        // 调用dao方法
        accountDao.outMoney(out, money);
        accountDao.inMoney(in, money);
    }

}

3.3 全注解

import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.ComponentScan;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.jdbc.core.JdbcTemplate;
    import org.springframework.jdbc.datasource.DataSourceTransactionManager;
    import org.springframework.transaction.PlatformTransactionManager;
    import org.springframework.transaction.annotation.EnableTransactionManagement;
    
    import org.springframework.jdbc.datasource.DriverManagerDataSource;
    
    @Configuration
    @ComponentScan(basePackages="cn.qcby")
    @EnableTransactionManagement        // 开启事务注解
    public class SpringTransactionConfig {
        
        /**
         * @return
         * @throws Exception 
         */
        @Bean(name="dataSource")
        public DataSource createDataSource() throws Exception{
            // 创建连接池对象，Spring框架内置了连接池对象
            DriverManagerDataSource dataSource = new DriverManagerDataSource();
            // 设置4个参数
            dataSource.setDriverClassName("com.mysql.jdbc.Driver");
            dataSource.setUrl("jdbc:mysql:///spring_db");
            dataSource.setUsername("root");
            dataSource.setPassword("root");
            return dataSource;
        }
        
        /**
         * 创建模板对象
         * @return
         */
        @Resource(name="dataSource")        // 不仅可以作用在属性上，也可以作用方法上。
        @Bean(name="jdbcTemplate")          // 把JdbcTemplate保存到IOC容器中
        public JdbcTemplate createJdbcTemplate(DataSource dataSource){
            JdbcTemplate template = new JdbcTemplate(dataSource);
            return template;
        }
        
        /**
         * 创建平台事务管理器对象
         * @param dataSource
         * @return
         */
        @Resource(name="dataSource")
        @Bean(name="transactionManager")
        public PlatformTransactionManager createTransactionManager(DataSource dataSource){
            DataSourceTransactionManager manager = new DataSourceTransactionManager(dataSource);
            return manager;
        }

@Resource注解是依赖注入的注解，根据name唯一查找bean

@Autowired也是依赖注入的注解，但是@Autowired只能根据类型注入

所以@Autowired一般和@Controller，@Component，@Service，@Repository配合使用

而@Resource一般和@Bean使用

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

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

相关文章

4A的「A」会变成AI的「A」吗？

4A的「A」会变成AI的「A」吗？

戛纳国际创意节上&#xff0c;广告集团WPP的全球CEO Mark Read 和英国CEO Karen Blackett 解释了WPP如何应对AIGC所带来的「威胁」。同时&#xff0c;Mark Read 与Elon Musk对话&#xff0c;讨论「技术创新的变革力量&#xff0c;人工智能如何重塑创造力、商业和社会&#xff0…
阅读更多...
基于uni-app与图鸟UI的移动应用模板构建研究

基于uni-app与图鸟UI的移动应用模板构建研究

摘要 随着移动互联网技术的迅猛发展&#xff0c;移动端应用已成为企业展示形象、提供服务的重要窗口。本文基于uni-app框架和图鸟UI设计&#xff0c;深入探讨了如何高效构建覆盖多个领域的移动端应用模板。通过对商城、办公、投票、生活服务等多种类型模板的详细介绍&#xff…
阅读更多...
使用uniapp.pageScrollTo方法进行页面滚动

使用uniapp.pageScrollTo方法进行页面滚动

先看看是不是你想要的&#xff1a; 需求&#xff1a; 有个填写数据的单子在提交的时候&#xff0c;会对必填项做校验&#xff0c;如果必填项没有数据的话&#xff0c;必填项校验生效给出提示&#xff0c;并且页面滚动到第一个需要填写数据的地方。 开发&#xff1a; 因为这个…
阅读更多...
Ubuntu无法安全地用该源进行更新，所以默认禁用该源。

Ubuntu无法安全地用该源进行更新，所以默认禁用该源。

解决方案 1. 获取并添加缺失的 GPG 公钥 可以使用 apt-key 命令来添加缺失的公钥。根据错误信息&#xff0c;缺失的公钥是 3B4FE6ACC0B21F32。 sudo apt-key adv --keyserver keyserver.ubuntu.com --recv-keys 3B4FE6ACC0B21F322. 更新软件包列表 添加公钥后&#xff0c;更…
阅读更多...
[Go Web] Kratos 验证码业务

[Go Web] Kratos 验证码业务

文章目录 1.环境准备2.验证码服务2.1 kratos 初始化验证码服务项目2.2 使用 Protobuf 定义验证码生成接口2.3 业务逻辑代码实现 1.环境准备 protoc和protoc-gen-go插件安装和kratos工具安装 protoc下载 下载二进制文件&#xff1a;https://github.com/protocolbuffers/protobu…
阅读更多...
智能体实战：开发一个集成国内AI平台的GPTs，自媒体高效智能助手

智能体实战：开发一个集成国内AI平台的GPTs，自媒体高效智能助手

文章目录 一&#xff0c;什么是GPTs二&#xff0c;开发GPTs1&#xff0c;目标2&#xff0c;开发2.1 打开 GPTS&#xff1a;https://chat.openai.com/gpts2.2 点击 Create 创建一个自己的智能体 2.3 配置GPTs2.4 配置外挂工具2.4.1 配置Authentication-授权2.4.1.1 生成语聚AI的…
阅读更多...
kafka consumer客户端消费逻辑解析

kafka consumer客户端消费逻辑解析

kafka consumer客户端消费逻辑解析 一、主要消费步骤二、提交策略【步骤2代码解析】【提交策略总结】 三、拉取策略&#xff08;待补充&#xff09;四、消费策略【代码解析】【消费策略总结】 一、主要消费步骤 这是kafka客户端拉取消息的入口&#xff0c;有4个主要部分 1、启…
阅读更多...
UEFA EURO 2024 GERMANY

UEFA EURO 2024 GERMANY

UEFA EURO 2024 GERMANY 画个流程图&#xff0c;哈哈
阅读更多...
openlayer 鼠标点击船舶，打开船舶简单弹框

openlayer 鼠标点击船舶，打开船舶简单弹框

背景&#xff1a; 对创建的地图对象&#xff0c;可以添加上监听事件&#xff0c;常用的有&#xff1a;地图点击事件、鼠标移动事件。 通过监听这些事件&#xff0c;又可以区分不同图层的不同要素&#xff0c;获取不同数据&#xff1b; 根据这些数据&#xff0c;又可以发起网络请…
阅读更多...
快速阅读参考文献：kimi请求出战！

快速阅读参考文献：kimi请求出战！

学境思源&#xff0c;一键生成论文初稿&#xff1a; AcademicIdeas - 学境思源AI论文写作 上篇文章&#xff0c;我们为大家演示了“如何使用kimi创建论文中的流程图”。今天继续为大家介绍“使用kimi快速阅读学术参考文献”。 在学术研究的海洋中&#xff0c;文献阅读是一项基…
阅读更多...
码农：如何快速融入团队

码农：如何快速融入团队

问题&#xff1a; 码农如何快速融入团队&#xff1f; 记住一个标准&#xff1a;能干事、能抗事。 总结一个字&#xff1a; 靠谱。 适用范围&#xff1a;新手码农、老司机码农、测试、DBA、运维、产品经理、项目经理、架构师、技术专家、。。。。适用于任何行业的打工者。 下面要…
阅读更多...
2、逻辑回归

2、逻辑回归

1. 为什么要叫逻辑回归？ 逻辑回归模型的名称可能会引起一些混淆，因为它名字中包含了"回归"这个词，但实际上它是一种用于解决分类问题的模型，而不是回归问题。 逻辑回归最初是从线性回归模型演变而来的。线性回归用于预测连续的数值输出，逻辑回归则是在线性回归…
阅读更多...
Java-记一次Springboot版本升级导致的问题

Java-记一次Springboot版本升级导致的问题

前言 根据相关情况&#xff0c;需要将SpringBoot的版本由原来的2.1.8.RELEASE版本升级至2.3.8.RELEASE。 启动项目后报错&#xff1a; 具体报错信息如下&#xff1a; Description: An attempt was made to call a method that does not exist. The attempt was made from the…
阅读更多...
uni-app picker多列选项

uni-app picker多列选项

预期实现的效果&#xff1a; 选中后的效果&#xff1a; // Dom部分 <template><picker mode"multiSelector" :range"ssqRange" range-key"name" columnchange"ssqColumnChange" change"ssqChange" class"p…
阅读更多...
O2OA(翱途) 开发平台之HTTP端口规划

O2OA(翱途) 开发平台之HTTP端口规划

O2OA(翱途) 开发平台[下称O2OA开发平台或者O2OA]采用相对灵活的系统架构&#xff0c;支持三种服务器运行的方式。本篇主要阐述合并服务运行独立服务运行代理端口运行三种服务器运行方式。 一、先决条件&#xff1a; 1、O2Server服务器正常运行&#xff0c;系统安装部署请参考文…
阅读更多...
IDEA使用Apidocx插件在RAP生成接口文档

IDEA使用Apidocx插件在RAP生成接口文档

第一步 安装插件&#xff0c;安装最新的1.1.7即可&#xff0c;插件与idea版本对照 第二步 输入对应的IP或域名&#xff0c;端口说明&#xff1a; 1. 38080&#xff1a;为后端数据 API 服务器&#xff08;rap2-delos&#xff09; 2. 3000&#xff1a;为前端静态资源服务&…
阅读更多...
使用North自部署图床服务

使用North自部署图床服务

图床 图床可以把图片转为链接&#xff0c;从而方便我们书写、分享博客&#xff0c;目前图床主要分为以下几类: 利用 Git 仓库存储对象存储&#xff08;OSS、COS、七牛云等&#xff09;免费公共图床&#xff08;SM.MS、聚合图床、ImgTP、Postimage等&#xff09; 但上述图床都…
阅读更多...
华侨大学24计算机考研数据速览，专硕22408复试线290分，学硕11408接收调剂！

华侨大学24计算机考研数据速览，专硕22408复试线290分，学硕11408接收调剂！

华侨大学计算机专业创建于1980年&#xff0c;是福建省最早设立计算机专业的高校之一。1982年成立计算机系&#xff0c;2008年成立计算机科学与技术学院。根据“华侨大学计算机科学与技术学院网站”资料&#xff0c;该院有计算机科学与技术、软件工程、网络工程3个本科专业&…
阅读更多...
【MySQL】架构体系概览

【MySQL】架构体系概览

本文使用的MySQL版本是8.0 MySQL架构 ​MySQL架构整体由外部程序和MySQL服务器构成。其中内部服务器分成连接层&#xff0c;服务层&#xff0c;服务管理和公共组件&#xff0c;存储引擎层和文件系统层。 连接层 连接层的作用是处理客户端的连接。 网络端口 一台MySQL服务器…
阅读更多...
kettle使用手册 安装9.0版本 建议设置为英语

kettle使用手册 安装9.0版本 建议设置为英语

0.新建转换的常用组件 0. Generate rows 定义一个字符串 name value就是字符串的值 0.1 String operations 字段转大写 去空格 1. Json input 来源于一个json文件 1.json 或mq接收到的data内容是json字符串 2. Json output 定义Jsonbloc值为 data, 左侧Fieldname是数据库…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023