精华内容
下载资源
问答
  • 将数据导入R后,用以下...Error in FUN(left, right) : 二进列运算符中有数值参数 在线查阅后,发现上述代码是直接利用"as.matrix()"进行格式转换,导致报错,具体更改方法为利用apply函数对每个元素进行类型转化,

    将数据导入R后,用以下代码将数据从字符串转换为数值,在笔者自己电脑上运行以下代码报错,而另外一台电脑运行正常。

    rownames(data1) = data1[,1]
    data1 <- data1[,-1]
    data1 <- as.matrix(data1)
    

    报错内容

    Error in FUN(left, right) : 二进列运算符中有非数值参数
    

    在线查阅后,发现上述代码是直接利用"as.matrix()"进行格式转换,导致报错,具体更改方法为利用apply函数对每个元素进行类型转化,无需对某一列进行单独处理。

    修改后代码:

    rownames(data1) = data1[,1]
    data1 <- data1[,-1]
    data1 <- apply(data1, 2, as.numeric)
    data1 <- as.matrix(data1)
    

    运行以上代码,问题解决。

    参考内容:

    1. 【R语言报错解决】—存在非数值型变量,Error in c_max * c_min : non-numeric argument to binary operator,如何在数据导入后转为数值型变量?
    2. R语言read.csv函数读取数据,报出错误:二进列运算符中有非数值参数
    3. R语言dataframe/matrix计算报错Error in FUN(left, right) : 二进列运算符中有非数值参数的原因和解决方法
    展开全文
  • spring项目整合redis

    2021-08-06 17:21:19
    spring项目整合redis1、添加maven依赖2、添加redis.properties配置文件3、添加工具类JedisUtil4、牛刀小试5、配置参数相关介绍 想必大家都比较熟悉spring项目整合redis。最近由于接触到spring的java项目需要用到...


    最近由于接触到非spring的java项目需要用到redis缓存中间件,所以专门整理了一下分享给大家!我想到的方式是使用jedis的方式操作redis,jedis是通过redis.clients.jedis.JedisPool来管理,即通过池来管理,通过池对象获取jedis实例,然后通过jedis实例直接操作redis服务的
    方法如下:

    1、添加maven依赖

        <dependency>
          <groupId>redis.clients</groupId>
          <artifactId>jedis</artifactId>
          <version>2.9.0</version>
          <type>jar</type>
          <scope>compile</scope>
        </dependency>
    

    2、添加redis.properties配置文件

    #最大活动对象数
    redis.pool.maxTotal=1000
    #最大能够保持idel状态的对象数
    redis.pool.maxIdle=50
    #资源池确保最少空闲的连接数;默认值:0
    redis.pool.minIdle=5
    #当资源池连接用尽后,调用者的最大等待时间(单位为毫秒) -1:表示永不超时;使用建议:不建议使用默认值
    redis.pool.maxWaitMillis=20000
    #当池内没有返回对象时,最大等待时间
    redis.pool.maxWait=300
    #当调用borrow Object方法时,是否进行有效性检查
    redis.pool.testOnBorrow=false
    redis.host = 127.0.0.1
    redis.port = 6379
    redis.timeout=30000
    redis.password =123456
    redis.database = 0
    

    3、添加工具类JedisUtil

    这里的工具类只是实现了基本的方法,具体方法大家可以自行拓展

    package com.redic.sale.config;
     
    import java.util.List;
    import java.util.Map;
    import java.util.Properties;
    import java.util.Set;
     
    import redis.clients.jedis.Jedis;
    import redis.clients.jedis.JedisPool;
    import redis.clients.jedis.JedisPoolConfig;
     
    /**
     * redis工具类
     * @author xdy
     */
    public class JedisUtil {
        private static JedisPool jedisPool = null;
     
        private JedisUtil() {
     
        }
        
        //写成静态代码块形式,只加载一次,节省资源
        static {
            Properties properties = PropertyUtil.loadProperties("properties/redis.properties");
            String host = properties.getProperty("redis.host");
            String port = properties.getProperty("redis.port");
            String password = properties.getProperty("redis.password");
            String timeout = properties.getProperty("redis.timeout");
            String maxIdle = properties.getProperty("redis.pool.maxIdle");
            String maxTotal = properties.getProperty("redis.pool.maxTotal");
            String maxWaitMillis = properties.getProperty("redis.pool.maxWaitMillis");
            String testOnBorrow = properties.getProperty("redis.pool.testOnBorrow");
     
            JedisPoolConfig config = new JedisPoolConfig();
            //控制一个pool可分配多少个jedis实例,通过pool.getResource()来获取;
            //如果赋值为-1,则表示不限制;如果pool已经分配了maxActive个jedis实例,则此时pool的状态为exhausted(耗尽)。
            config.setMaxTotal(Integer.parseInt(maxTotal));
            //控制一个pool最多有多少个状态为idle(空闲的)的jedis实例。
            config.setMaxIdle(Integer.parseInt(maxIdle));
            //表示当borrow(引入)一个jedis实例时,最大的等待时间,如果超过等待时间,则直接抛出JedisConnectionException;
            config.setMaxWaitMillis(Long.parseLong(maxWaitMillis));
            //在borrow一个jedis实例时,是否提前进行validate操作;如果为true,则得到的jedis实例均是可用的;
            config.setTestOnBorrow(Boolean.valueOf(testOnBorrow));
     
            jedisPool = new JedisPool(config, host, Integer.parseInt(port), Integer.parseInt(timeout), null);
        }
     
        /**
         * 从jedis连接池中获取获取jedis对象
         *
         * @return
         */
        private Jedis getJedis() {
            return jedisPool.getResource();
        }
     
        private static final JedisUtil jedisUtil = new JedisUtil();
     
        /**
         * 获取JedisUtil实例
         *
         * @return
         */
        public static JedisUtil getInstance() {
            return jedisUtil;
        }
     
        /**
         * 回收jedis(放到finally中)
         *
         * @param jedis
         */
        private void returnJedis(Jedis jedis) {
            if (null != jedis && null != jedisPool) {
                jedisPool.returnResource(jedis);
            }
        }
     
        /**
         * 销毁连接(放到catch中)
         *
         * @param jedis
         */
        private static void returnBrokenResource(Jedis jedis) {
            if (null != jedis && null != jedisPool) {
                jedisPool.returnResource(jedis);
            }
        }
    
        /**
         * 添加一个键值对,如果键存在不在添加,如果不存在,添加完成以后设置键的有效期
         * @param key
         * @param value
         * @param timeOut 秒
         */
        public void set(String key,String value,int timeOut){
            Jedis jedis = getJedis();
            if(0!=jedis.setnx(key, value)){
                jedis.expire(key, timeOut);
            }
            returnJedis(jedis);
        }
    
        /**
         * 设置永不过期的键值对
         * @param key
         * @param value
         */
        public void set(String key,String value){
            Jedis jedis = getJedis();
            jedis.set(key,value);
            returnJedis(jedis);
        }
    
    
        /**
         * 获取一个键值对
         * @param key
         * @return
         */
        public String get(String key){
            Jedis jedis = getJedis();
            returnJedis(jedis);
            return jedis.get(key);
        }
     
        /**
         * 添加sorted set
         *
         * @param key
         * @param value
         * @param score
         */
        public void zadd(String key, String value, double score) {
            Jedis jedis = getJedis();
            jedis.zadd(key, score, value);
            returnJedis(jedis);
        }
     
        /**
         * 返回指定位置的集合元素,0为第一个元素,-1为最后一个元素
         * @param key
         * @param start
         * @param end
         * @return
         */
        public Set<String> zrange(String key, int start, int end) {
            Jedis jedis = getJedis();
            Set<String> set = jedis.zrange(key, start, end);
            returnJedis(jedis);
            return set;
        }
     
        /**
         * 获取给定区间的元素,原始按照权重由高到低排序
         * @param key
         * @param start
         * @param end
         * @return
         */
        public Set<String> zrevrange(String key, int start, int end) {
            Jedis jedis = getJedis();
            Set<String> set = jedis.zrevrange(key, start, end);
            returnJedis(jedis);
            return set;
        }
     
        /**
         * 添加对应关系,如果对应关系已存在,则覆盖
         *
         * @param key
         * @param map 对应关系
         * @return 状态,成功返回OK
         */
        public String hmset(String key, Map<String, String> map) {
            Jedis jedis = getJedis();
            String s = jedis.hmset(key, map);
            returnJedis(jedis);
            return s;
        }
     
        /**
         * 向List头部追加记录
         *
         * @param key
         * @param value
         * @return 记录总数
         */
        public long rpush(String key, String value) {
            Jedis jedis = getJedis();
            long count = jedis.rpush(key, value);
            returnJedis(jedis);
            return count;
        }
     
        /**
         * 向List头部追加记录
         *
         * @param key
         * @param value
         * @return 记录总数
         */
        private long rpush(byte[] key, byte[] value) {
            Jedis jedis = getJedis();
            long count = jedis.rpush(key, value);
            returnJedis(jedis);
            return count;
        }
     
        /**
         * 删除
         *
         * @param key
         * @return
         */
        public long del(String key) {
            Jedis jedis = getJedis();
            long s = jedis.del(key);
            returnJedis(jedis);
            return s;
        }
     
        /**
         * 从集合中删除成员
         * @param key
         * @param value
         * @return 返回1成功
         * */
        public long zrem(String key, String... value) {
            Jedis jedis = getJedis();
            long s = jedis.zrem(key, value);
            returnJedis(jedis);
            return s;
        }
        
        public void saveValueByKey(int dbIndex, byte[] key, byte[] value, int expireTime)
                throws Exception {
            Jedis jedis = null;
            boolean isBroken = false;
            try {
                jedis = getJedis();
                jedis.select(dbIndex);
                jedis.set(key, value);
                if (expireTime > 0) {
                    jedis.expire(key, expireTime);
                }
            } catch (Exception e) {
                isBroken = true;
                throw e;
            } finally {
                returnResource(jedis, isBroken);
            }
        }
        
        public byte[] getValueByKey(int dbIndex, byte[] key) throws Exception {
            Jedis jedis = null;
            byte[] result = null;
            boolean isBroken = false;
            try {
                jedis = getJedis();
                jedis.select(dbIndex);
                result = jedis.get(key);
            } catch (Exception e) {
                isBroken = true;
                throw e;
            } finally {
                returnResource(jedis, isBroken);
            }
            return result;
        }
        
        public void deleteByKey(int dbIndex, byte[] key) throws Exception {
            Jedis jedis = null;
            boolean isBroken = false;
            try {
                jedis = getJedis();
                jedis.select(dbIndex);
                jedis.del(key);
            } catch (Exception e) {
                isBroken = true;
                throw e;
            } finally {
                returnResource(jedis, isBroken);
            }
        }
        
        public void returnResource(Jedis jedis, boolean isBroken) {
            if (jedis == null) {
                return;
            }
            if (isBroken) {
                jedisPool.returnBrokenResource(jedis);
            } else {
                jedisPool.returnResource(jedis);
            }
        }
        
        /**
         * 获取总数量
         * @param key
         * @return
         */
        public long zcard(String key) {
            Jedis jedis = getJedis();
            long count = jedis.zcard(key);
            returnJedis(jedis);
            return count;
        }
     
        /**
         * 是否存在KEY
         * @param key
         * @return
         */
        public boolean exists(String key) {
            Jedis jedis = getJedis();
            boolean exists = jedis.exists(key);
            returnJedis(jedis);
            return exists;
        }
     
        /**
         * 重命名KEY
         * @param oldKey
         * @param newKey
         * @return
         */
        public String rename(String oldKey, String newKey) {
            Jedis jedis = getJedis();
            String result = jedis.rename(oldKey, newKey);
            returnJedis(jedis);
            return result;
        }
     
        /**
         * 设置失效时间
         * @param key
         * @param seconds
         */
        public void expire(String key, int seconds) {
            Jedis jedis = getJedis();
            jedis.expire(key, seconds);
            returnJedis(jedis);
        }
     
        /**
         * 删除失效时间
         * @param key
         */
        public void persist(String key) {
            Jedis jedis = getJedis();
            jedis.persist(key);
            returnJedis(jedis);
        }
        
        /**
         * 返回指定key序列值 
         * @param key
         * @return
         */
        public long incr(String key){
        	Jedis jedis = getJedis();
        	long l = jedis.incr(key);
            returnJedis(jedis);
            return l;
        }
    
        public static void main(String[] args) {
            System.out.println(JedisUtil.getInstance().currentTimeSecond());
        }
        
        /**
         * 获取当前时间 
         * @return 秒
         */
        public long currentTimeSecond(){
        	Long l = 0L;
        	Jedis jedis = getJedis();
        	Object obj = jedis.eval("return redis.call('TIME')",0);
        	if(obj != null){
        		List<String> list = (List)obj;
        		l = Long.valueOf(list.get(0));
        	}
            returnJedis(jedis);
            return l;
        }
    }
    

    这里是加在配置文件的工具类:

    package com.redic.sale.config;
     
    import java.io.IOException;
    import java.io.InputStream;
    import java.util.Properties;
     
    /**
     * 属性文件加载工具类
     * @author xdy
     */
    public class PropertyUtil {
       
        //加载property文件到io流里面
        public static Properties loadProperties(String propertyFile) {
        	Properties properties = new Properties();
            try {
                InputStream is = PropertyUtil.class.getClassLoader().getResourceAsStream(propertyFile);
                if(is == null){
                	is = PropertyUtil.class.getClassLoader().getResourceAsStream("properties/" + propertyFile);
                }
                properties.load(is);
            } catch (IOException e) {
                e.printStackTrace();
            }
            return properties;
        }
    }
    

    4、牛刀小试

        public static void main(String[] args) {
            JedisUtil instance = JedisUtil.getInstance();
            instance.set("key","测试一下",30);
            System.out.println(instance.get("key"));
        }
    

    5、配置参数相关介绍

    maxTotal:资源池中最大连接数;默认值:8
    maxIdle:资源池允许最大空闲的连接数;默认值:8
    minIdle:资源池确保最少空闲的连接数;默认值:0
    blockWhenExhausted:当资源池用尽后,调用者是否要等待。只有当为true时,下面的maxWaitMillis才会生效;默认值:true;使用建议:建议使用默认值
    maxWaitMillis:当资源池连接用尽后,调用者的最大等待时间(单位为毫秒) -1:表示永不超时;使用建议:不建议使用默认值
    testOnBorrow:向资源池借用连接时是否做连接有效性检测(ping),无效连接会被移除;默认值:false;使用建议:业务量很大时候建议设置为false(多一次ping的开销)。
    testOnReturn:向资源池归还连接时是否做连接有效性检测(ping),无效连接会被移除;默认值:false;使用建议:业务量很大时候建议设置为false(多一次ping的开销)。
    jmxEnabled:是否开启jmx监控,可用于监控;默认值:true;使用建议:建议开启,但应用本身也要开启
    
    展开全文
  • 2 功能整合参数 (function integration) 包括

    目录

    2 功能整合的参数 (function integration)

    2.1 CPL

    2.2 Global efficiency 

    2.3 note

    3 small-world 小世界

    参考资料


    distance

    定义:两个节点之间的最短路线的长度

    计算:

    从节点i到j有多种连接方式,其最短连接方式g中的所有边的和(非加权)。对于不能连接的两个节点,其距离趋近于∞。

    2 功能整合的参数 (function integration)

    包括

    • Characteristic path length(CPL),特征路径长度
    • Global efficiency,全局效率

    2.1 CPL

    意义: 最常用的功能分割参数

    计算:

    Li:i节点与其他节点的(最短)距离的平均

    CPL即为所有节点 平均最短距离 的平均

    2.2 Global efficiency 

    计算:与CPL相对应,但全局效率是节点与其他节点的最短距离的倒数的平均而来。CPL容易受到较大的距离的影响,而全局效率容易受到较小距离的影响。

    2.3 note

    • 对于未连接的两节点,其length→∞,E→0.
    • 不考虑自身与自身的连接
    • 对于加权的情况,权重越高,说明连接越强,其length约小。

    3 small-world 小世界

    定义:比随机网络更加的集群化,又拥有与随机网络相似的特征路径长度。是分割与整合的平衡

    将随机网络作为基准,如果所研究网络相对于随机网络具有较大的集群系数和近似的最短路径长度, 即γ = Creal/Crandom>> 1, λ= Lreal/Lrandom ~ 1 (其中脚标 random 表示随机网络,real 表示真实网络), 则该网络属于“小世界”网络范畴. σ =γ /λ来衡量“小世界”特性, 当σ>1 时网络具有“小世界”属性, 且σ越大网络的“小世界”属性越强.(脑网络基本概念_Elina05的博客-CSDN博客

    参考资料

    Complex network measures of brain connectivity: Uses and interpretations Mikail Rubinov ,  Olaf Sporns     doi: 10.1016/j.neuroimage.2009.10.003

    脑网络基本概念_Elina05的博客-CSDN博客

     

    展开全文
  • springboot整合hibernate(JPA)(一) springboot整合hibernate,jpa,若是jpa就简单了,但是公司项目只有hibernate,并要求支持多数据库,因此记录下整合开发了。基本入门可参考官网 ...为支持多数据库,下面将实现...

    springboot整合hibernate(非JPA)(一)

    springboot整合hibernate,非jpa,若是jpa就简单了,但是公司项目只有hibernate,并要求支持多数据库,因此记录下整合开发了。基本入门可参考官网
    https://docs.jboss.org/hibernate/orm/5.5/quickstart/html_single/#tutorial_annotations
    为支持多数据库,下面将实现:

    1、springboot2.3.7整合hibernate最新稳定版Hibernate ORM 5.5(2021年7月11日21:53:22)

    2、实现ID主键自动生成(为支持MySQL、postgre SQL、Oracle)表关联

    第二篇移步:https://blog.csdn.net/weixin_44480167/article/details/118662257

    一、创建基本springboot项目

    在这里插入图片描述

    二、引入依赖

    		<!--hibernate的核心-->
            <dependency>
                <groupId>org.hibernate</groupId>
                <artifactId>hibernate-core</artifactId>
                <version>5.5.3.Final</version>
            </dependency>
            <!--用于hibernate整合spring的支持-->
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-orm</artifactId>
                <version>5.2.12.RELEASE</version>
            </dependency>
            <!--使用阿里的连接池-->
            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>druid-spring-boot-starter</artifactId>
                <version>1.2.6</version>
            </dependency>
            <!--用于ID生成-->
            <dependency>
                <groupId>cn.hutool</groupId>
                <artifactId>hutool-core</artifactId>
                <version>5.7.3</version>
            </dependency>
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <scope>runtime</scope>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
            </dependency>
    

    三、配置数据库

    application.properties

    # 应用名称
    spring.application.name=springboot-hibernate
    # 数据库驱动:
    spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
    # 数据源名称
    spring.datasource.name=defaultDataSource
    # 数据库连接地址
    spring.datasource.url=jdbc:mysql://localhost:3306/blue?serverTimezone=UTC
    # 数据库用户名&密码:
    spring.datasource.username=root
    spring.datasource.password=123456
    # 应用服务 WEB 访问端口
    server.port=8080
    

    配置数据源:

    import com.alibaba.druid.pool.DruidDataSource;
    import org.springframework.beans.factory.annotation.Configurable;
    import org.springframework.boot.context.properties.ConfigurationProperties;
    import org.springframework.context.annotation.Bean;
    
    import javax.sql.DataSource;
    
    @Configurable
    public class DataSourceConfig {
    
        @Bean
        @ConfigurationProperties("spring.datasource")
        public DataSource dataSource() {
            DruidDataSource source = new DruidDataSource();
            //source.setDriverClassName("com.mysql.cj.jdbc.Driver");
            source.setName("test");
            source.setInitialSize(1);
            //最大活动
            source.setMaxActive(10);
            source.setMaxWait(60000);
            //配置间隔多久才进行一次检测,检测需要关闭的空闲连接,单位是毫秒
            source.setTimeBetweenEvictionRunsMillis(60000);
            //配置一个连接在池中最小生存的时间,单位是毫秒
            source.setMinEvictableIdleTimeMillis(300000);
            //每分钟打印一次连接状态日志
            //source.setTimeBetweenLogStatsMillis(60000);
            return source;
        }
    }
    

    配置Hibernate

    package top.lingkang.springboothibernate.config;
    
    import com.alibaba.druid.pool.DruidDataSource;
    import org.springframework.context.annotation.Bean;
    import org.springframework.orm.hibernate5.LocalSessionFactoryBean;
    import org.springframework.stereotype.Component;
    
    import javax.annotation.Resource;
    import javax.sql.DataSource;
    import java.util.Properties;
    
    @Component
    public class HibernateToConfig {
    
        @Resource
        private DataSource dataSource;
    
        /**
         * 此处bean为根据 hibernate 官网配置文件 hibernate.cfg.xml 改造的
         * https://docs.jboss.org/hibernate/orm/5.5/quickstart/html_single/hibernate-tutorials.zip
         *
         * @return
         */
        @Bean
        public LocalSessionFactoryBean sessionFactory() {
            LocalSessionFactoryBean bean = new LocalSessionFactoryBean();
            bean.setDataSource(dataSource);
            // 扫描实体类
            bean.setPackagesToScan("top.lingkang.springboothibernate.entity");
            Properties properties = new Properties();
            properties.setProperty("current_session_context_class", "thread");
            DruidDataSource druidDataSource = (DruidDataSource) dataSource;
            properties.setProperty("connection.pool_size", String.valueOf(druidDataSource.getMaxActive()));
            // 配置方言 mysql 5.7.34
            properties.setProperty("hibernate.dialect", "org.hibernate.dialect.MySQL57Dialect");
            //        <!-- 控制台打印SQL -->
            properties.setProperty("hibernate.show_sql", "true");
            // 制台打印SQL格式化
            //properties.setProperty("hibernate.format_sql", "true");
            /**
             * create:表示启动的时候先drop,再create
             * create-drop: 也表示创建,只不过再系统关闭前执行一下drop
             * update: 这个操作启动的时候会去检查schema是否一致,如果不一致会做scheme更新
             * validate: 启动时验证现有schema与你配置的hibernate是否一致,如果不一致就抛出异常,并不做更新
             */
            // 首次启动使用 create 让bean自动生成表,之后使用 update模式即可
            properties.setProperty("hibernate.hbm2ddl.auto", "create");
    
            bean.setHibernateProperties(properties);
            return bean;
        }
    
    }
    

    配置自定义ID生成

    package top.lingkang.springboothibernate.config;
    
    import cn.hutool.core.lang.Snowflake;
    import cn.hutool.core.util.IdUtil;
    import org.hibernate.HibernateException;
    import org.hibernate.MappingException;
    import org.hibernate.engine.spi.SharedSessionContractImplementor;
    import org.hibernate.id.Configurable;
    import org.hibernate.id.IdentifierGenerator;
    import org.hibernate.service.ServiceRegistry;
    import org.hibernate.type.Type;
    
    import java.io.Serializable;
    import java.util.Properties;
    
    /**
     * 采用雪花算法生成主键
     * 2021年7月11日22:11:55
     */
    public class PrimaryGenerator implements Configurable, IdentifierGenerator {
        //参数1为终端ID
        //参数2为数据中心ID
        Snowflake snowflake = IdUtil.getSnowflake(1, 1);
        private String pre = "";
    
        @Override
        public void configure(Type type, Properties params, ServiceRegistry serviceRegistry) throws MappingException {
            String prefix = params.getProperty("prefix");
            if (prefix != null)
                this.pre = prefix;
        }
    
        @Override
        public Serializable generate(SharedSessionContractImplementor session, Object object) throws HibernateException {
            //雪花算法生成ID
            return pre + snowflake.nextIdStr();
        }
    }
    
    

    编写实体映射
    user表

    package top.lingkang.springboothibernate.entity;
    
    import lombok.Data;
    import org.hibernate.annotations.GenericGenerator;
    
    import javax.persistence.*;
    import java.util.Date;
    
    @Data
    @Entity
    @Table(name = "t_user")
    public class UserBean {
        // 主键采用string为了兼容更多数据库
        @Id
        @Column(length = 20)
        @GeneratedValue(strategy = GenerationType.AUTO, generator = "gg")
        //自定义生成主键
        @GenericGenerator(name = "gg", strategy = "top.lingkang.springboothibernate.config.PrimaryGenerator")
        private String id;
        @Column(length = 40)
        private String username;
        @Column(length = 64)
        private String password;
        @Column(length = 20)
        private String nickname;
        @Column(name = "create_time")
        private Date createTime;
    }
    

    用户的角色表

    package top.lingkang.springboothibernate.entity;
    
    import lombok.Data;
    import org.hibernate.annotations.GenericGenerator;
    
    import javax.persistence.*;
    
    @Data
    @Entity
    @Table(name = "T_USER_ROLE")// 大小写不同,用于兼容不同数据库
    public class UserRoleBean {
        // 主键采用string为了兼容更多数据库
        @Id
        @Column(length = 24)
        @GeneratedValue(strategy = GenerationType.AUTO, generator = "gg")
        //自定义生成主键
        @GenericGenerator(name = "gg", strategy = "top.lingkang.springboothibernate.config.PrimaryGenerator",
                //自定义ID前缀
                parameters = {@org.hibernate.annotations.Parameter(name = "prefix", value = "R_")})
        private String id;
        @Column(name = "user_id",length = 20)
        private String userId;
        @Column(name = "role_id",length = 20)
        private String roleId;
    }
    

    首次启动使用 create 模式,启动完成即可生成对应的映射表在数据库:
    在这里插入图片描述
    在这里插入图片描述

    四、操作数据库

    4.1 增

        /**
         * 此处需要注意,hibernate的增删改需要事务提交,否则不能保存到数据库
         * import org.springframework.transaction.annotation.Transactional;
         */
        @Transactional
        @GetMapping("add")
        public Object add() {
            UserBean bean = new UserBean();
            bean.setCreateTime(new Date());
            bean.setUsername("lingkang");
            bean.setNickname("凌康");
            bean.setPassword("123456");
            System.out.println(sessionFactory.getCurrentSession().save(bean));
            return bean;
        }
    

    hibernate的增删改需要事务提交,否则不能保存到数据库。官网example:
    在这里插入图片描述

    4.2 改

        /**
         * 此处需要注意,hibernate的增删改需要事务提交,否则不能保存到数据库
         * import org.springframework.transaction.annotation.Transactional;
         */
        @Transactional
        @GetMapping("update")
        public Object update() {
            Session currentSession = sessionFactory.getCurrentSession();
            List<UserBean> id = currentSession.createQuery("from UserBean where id=:id")
                    .setParameter("id", "1414241573973135360").list();
            System.out.println(id);
            if (!id.isEmpty()){
                UserBean bean = id.get(0);
                bean.setNickname("凌康,你好!");
                // 更新
                currentSession.update(bean);
            }
            return id;
        }
    

    在这里插入图片描述

    4.3 删除

        /**
         * 此处需要注意,hibernate的增删改需要事务提交,否则不能保存到数据库
         * import org.springframework.transaction.annotation.Transactional;
         */
        @Transactional
        @GetMapping("delete")
        public Object delete() {
    //        UserBean bean = new UserBean();
    //        bean.setId("1414240012135960576");
            // 缺点,不存在的数据会报异常
            // sessionFactory.getCurrentSession().delete(bean);
            
            // 推荐  删除不会报异常
            int res = sessionFactory.getCurrentSession().createQuery("delete from UserBean  where id=:id")
                    .setParameter("id", "1414243500257579008").executeUpdate();
            System.out.println(res);
            return res;
        }
    

    4.4 查,留到下一章,

    查询比较复杂,存在多对多,一对多、一对一等关系,篇幅原因,留到一下章:

    https://blog.csdn.net/weixin_44480167/article/details/118662257

    这里贴出hibernate常用的BaseDao公共接口

    BaseDao接口

    import java.io.Serializable;
    import java.util.List;
    
    public interface BaseDao<T> {
        T save(T t);
    
        void delete(T entity);
    
        void update(T entity);
    
        T findById(Serializable id);
    
        List<T> findAll();
    }
    

    BaseDao接口实现

    import org.hibernate.SessionFactory;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Service;
    import top.lingkang.demohibernate.dao.BaseDao;
    
    import java.io.Serializable;
    import java.lang.reflect.ParameterizedType;
    import java.util.List;
    
    @Service
    public class BaseDaoImpl<T> implements BaseDao<T> {
        @Autowired
        private SessionFactory sessionFactory;
    
        @Override
        public T save(T entity) {
            sessionFactory.getCurrentSession().save(entity);
            return entity;
        }
    
        @Override
        public void delete(T entity) {
            sessionFactory.getCurrentSession().delete(entity);
        }
    
        @Override
        public void update(Object entity) {
            sessionFactory.getCurrentSession().update(entity);
        }
    
        @Override
        public T findById(Serializable id) {
            Class tclass = (Class<T>) ((ParameterizedType) getClass().getGenericSuperclass()).getActualTypeArguments()[0];
            return (T) sessionFactory.getCurrentSession().get(tclass, id);
        }
    
        @Override
        public List<T> findAll() {
            Class tclass = (Class<T>) ((ParameterizedType) getClass().getGenericSuperclass()).getActualTypeArguments()[0];
            return sessionFactory.getCurrentSession().createQuery(
                    "from " + tclass.getSimpleName()
            ).list();
        }
    }
    

    UserDao 继承使用如下:

    public interface UserDao extends BaseDao<UserBean>{
    }
    

    UserDao 继承使用实现如下:

    import org.springframework.stereotype.Service;
    import top.lingkang.demohibernate.dao.UserDao;
    import top.lingkang.demohibernate.entity.UserBean;
    
    @Service
    public class UserDaoImpl extends BaseDaoImpl<UserBean> implements UserDao {
    
    }
    

    调用如下

    	@Autowired
        private UserDao userDao;
    
        @Override
        public UserBean saveUser(UserBean bean) {
            return userDao.save(bean);
        }
    
    展开全文
  • 切面整合自定义注解,对接口请求参数进行校验 jar包依赖 aspectj : "org.aspectj:aspectjweaver:1.9.6", 自定义注解并设置需要校验的字段 @Target({ElementType.TYPE,ElementType.METHOD,ElementType.FIELD}...
  • SpringMVC中处理控制器参数的接口是HandlerMethodArgumentResolver,此接口有众多子类,分别处理不同(注解类型)的参数,下面只列举几个子类:RequestParamMethodArgumentResolver:解析处理使用了@RequestParam注解...
  • SpringBoot 整合HDFS

    2021-08-13 20:51:34
    文章目录SpringBoot 整合HDFS1 window本地测试前置操作2 整合代码2.1 pom2.2 code3 上传加载 SpringBoot 整合HDFS 1 window本地测试前置操作 本地安装hadhoop 2 整合代码 2.1 pom <!-- hadoop--> <...
  • springboot整合JPA

    2021-01-05 15:02:50
    今天跟着王老师学习了springboot整合JPA,一上午的学习后收益匪浅啊,记录一下,方便自己后续的学习和使用!跟着我来学习一下吧: 目录 1.什么是JPA呢? 2.借助spring data jpa整合JPA 2.1什么是Spring Data JPA ...
  • } } entity类 1、JwtAuthorization /** * 这个类是用来封装一些额外的请求参数到UsernamePasswordAuthenticationToken一起认证的, * 因为前期整合,暂时并没有用到,只是预留在此 */ public class ...
  • 电脑主板参数知识

    2021-07-16 07:42:08
    对于DIY硬件而言,判断其性能好坏不仅与品牌型号有关,重要的是需要学会看主板参数,与其它硬件一样,判断某硬件如何应该是从硬件的综合参数去了。主板参数之主板芯片组目前我们装机主要有Intel平台与AMD平台,两者...
  • 配置Swagger开关 5.1 enable()使用 配置是否启用Swagger,如果是false,在浏览器将无法访问 5.2 生产环境使用swagger application.properties切换环境 spring.profiles.active=pro SwaggerConfig.java @...
  • SSM整合与事务

    2021-04-26 18:57:46
      Spring就像是整个项目中装配bean的大工厂,在配置文件中可以指定使用特定的参数去调用实体类的构造方法来实例化对象。也可以称之为项目中的粘合剂。   Spring的核心思想是IoC(控制反转),即不再需
  • 第 2 节 参数优化 本地模式 严格模式 JVM重用 并行执行 推测执行 合并小文件 Fetch模式 第 3 节 SQL优化 列裁剪和分区裁剪 sort by 代替 order by group by 代替 count(distinct) group by 配置调整 ...
  • 对于数据访问层不管是关系型数据库还是关系型数据库,SpringBoot底层都是采用SpringData的方式进行统一处理数据库 SpringBoot整合JDBC 1.搭建SpringBoot项目 2.配置数据库相关信息(这里使用application.yaml配置...
  • 本篇文章带领大家如何在 SpringBoot 中整合 tio-websocket-server 搭建一个自己的 websocket 服务器 1、引入 maven 依赖 <!-- tio-websocket --> <dependency> <groupId>org.t-io</groupId>...
  • 对二叉树的前中后序递归以及递归算法以及层序遍历思想做了整合 因为某些书籍上对这类算法,写的非常笼统,所以,这里将从树的链式存储开始,结合整个 链表、栈、队列等结构来完成对树的学习,当然,这里也将会完美...
  • 网站整合支付宝支付

    2021-08-13 19:07:49
    对称加密 RSA、Elgamal等对等加密算法 公钥私钥 公钥和私钥是一个相对的概念,它们的公私性是相对生成者来说的。一对密钥生成后,保存在生成者手里的就是私钥,而生成者发布出去的就是公钥。 加密 一堆公私钥中...
  • springcloud整合Security

    2021-08-10 11:16:10
    } /** * anyRequest | 匹配所有请求路径 * access | SpringEl表达式结果为true时可以访问 * anonymous | 匿名可以访问 * denyAll | 用户不能访问 * fullyAuthenticated | 用户完全认证可以访问(remember-me下...
  • 简介主要介绍两种整合方式,分别是 springboot+mybatis 使用分包方式整合,和 springboot+druid+mybatisplus 使用注解方式整合。一、表结构在本地新建两个数据库,名称分别为db1和db2,新建一张user表,表结构如下:...
  • SpringBoot整合

    2021-01-06 23:20:41
    SpringBoot前言springBoot快速入门回忆:什么是springspring是如何简化java开发的:...ssm整合:框架极大的简化了整体的开发流程,配置也开始较为复杂; 此阶段项目打包都是在war包,整体程序也都是在Tomcat中运行 springBo
  • 本文研究静态资源文件的在 web 服务器的整合
  • SpringBoot整合线程池使用@Async

    千次阅读 2021-08-17 03:31:00
    自定义application.yml配置项及其值 和创建线程池的参数对应,具体含义见步骤2的成员属性注释,参数根据实际情况自行修改,这里仅作为演示 async: # 异步订单任务线程池参数 order-service: core-pool-size: 20 max...
  • Spring boot和Flink整合

    2021-03-21 12:40:43
    参数name表示IOC容器中已经实例化的bean的id或者name,且无论是id还是name都要求在IOC容器中是唯一的不能重名。那么这种方法就是通过id或name去查找获取bean. (2)getBean(Class type) 参数Class type表示要加载的...
  • 本文结合sklearn中的特征选择的方法,讲解相关方法函数及参数的含义。1. 移除低方差特征方差越大的特征,可以认为是对目标变量越有影响的特征,是我们需要研究的特征。可以利用 VarianceThreshold,移除方差不满足...
  • Oracle内存参数调优技术详解说明这段时间在学习Oracle的调整优化,在网上找到了一些资料,就转载到这里,与大家共同分享,希望对大家有帮助!内容实例结构oracle实例=内存结构+进程结构oracle实例启动的过程,其实...
  • 什么是超参数?学习器模型中一般有两类参数,一类是可以从数据中学习估计得到,我们称为参数(Parameter)。还有一类参数时无法从数据中估计,只能靠人的经验进行设计指定,我们称为超参数(Hyper parameter)。超参数是...
  • 3.2 Spring整合方式 3.2.1 配置 Apollo也支持和Spring整合(Spring 3.1.1+),只需要做一些简单的配置就可以了。 Apollo目前既支持比较传统的基于XML的配置,也支持目前比较流行的基于Java(推荐)的配置。 如果是...
  • mongoDb入门并整合springboot

    千次阅读 2021-10-16 14:59:56
    MongoDb是一种关系型数据库,是现在非常火热的noSQL。也被称为文档性数据库。(可存放json,xml等格式) mongodb与mysql命令对比 传统的关系数据库一般由数据库(database)、表(table)、记录(record)三个层次...
  • 设置必要的环境变量,此步骤必须#将默认的8000调试端口改成8001 并将默认的侦听地址 localhost 改成所有网卡平面,这样本机也能连接调试,达到远程调试的目的export JPDA_ADDRESS=0.0.0.0:80...
  • CSSSprites的目的就是通过整合图片,减少对服务器的请求数量,从而加快页面加载速度。介绍了CSSSprites技术的实现方法,优点和缺点。最后通过实例CSSSprites技术制作导航栏演示CSSSprites的使用。CSS Sprites的原理...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 110,220
精华内容 44,088
关键字:

非整合参数