精华内容
下载资源
问答
  • MySQL从其他数据表或者查询结果中创建数据

    从其他数据表中创建数据表

    从其他数据表中创建数据表,可以使用如下命令:

    create table ... like ...

    该语句将创建一个新的数据表作为原始数据表的一份空白副本。它将把原始数据表的所有列属性都会一摸一样的复制过来,但是数据表的内容是空的。如果我们想填充它,可以使用如下命令:

    Insert into .. select ..

    实例:

    复制t4到t5中
    这里写图片描述

    查看t4与t5结果
    这里写图片描述
    数据的复制
    这里写图片描述

    从查询结果中创建数据表

    使用如下命令,从一个select语句中创建新的数据表。

    create table ... select ...

    该语句优点是不仅仅创建了数据表,还复制了数据表中的数据。缺点是该语句不会复制所有的数据 列属性,如索引、auto_increment等。因为结果集本身就不带索引等。
    这里写图片描述
    可以看出t4中存在索引,但是t6中并不存在索引。

    展开全文
  • R语言与数据分析练习:创建和使用R语言数据集&数据的导入导出 实验一 创建和使用R语言数据集 一、实验目的: 了解R语言中的数据结构。 熟练掌握他们的创建方法,和函数中一些参数的使用。 对创建数据...

    R语言与数据分析练习:创建和使用R语言数据集&数据的导入导出


    实验一 创建和使用R语言数据集

    一、实验目的:

    1. 了解R语言中的数据结构。

    2. 熟练掌握他们的创建方法,和函数中一些参数的使用。

    3. 对创建的数据结构进行,排序、查找、删除等简单的操作。

    二、实验内容:

    1、向量的创建及因子的创建和查看

    有一份来自澳大利亚所有州和行政区的20个税务会计师的信息样本1 以 及他们各自所在地的州名。州名为:tas, sa, qld, nsw, nsw, nt, wa, wa, qld, vic, nsw, vic, qld, qld, sa, tas, sa, nt, wa, vic。

    手动创建州名txt文件

    在这里插入图片描述

    1) 将这些州名以字符串的形式保存在state当中

    # 1 用read.table函数导入txt文件
    setwd("D:/bigdata/R语言与数据分析/data06/")
    data = read.table("./demo.txt",sep=",")
    
    # 2 将这些州名以字符串的形式保存在state当中
    state = c(t(data))
    print(state)
    

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-wSwlANcI-1617800863149)(C:\Users\John\AppData\Roaming\Typora\typora-user-images\image-20210407204036154.png)]

    2) 创建一个为这个向量创建一个因子statef

    # 3 创建一个为这个向量创建一个因子statef
    statef <- factor(state)
    

    3) 使用levels函数查看因子的水平

    # 4 使用levels函数查看因子的水平
    print(levels(statef))
    

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Wc9ThmY8-1617800863150)(C:\Users\John\AppData\Roaming\Typora\typora-user-images\image-20210407204229664.png)]

    2、矩阵与数组。

    i. 创建一个4*5的数组如图,创建一个索引矩阵如图,用这个索引矩阵访问数组,观察结果。

    在这里插入图片描述

    # 5 创建一个4*5的数组
    x <-array(1:20,dim=(4:5))
    print(x)
    
    # 6 创建一个索引矩阵如图,用这个索引矩阵访问cell数组
    cell <- c(1,2,3,3,2,1)
    y <- matrix(cell , nrow = 3 , ncol = 2)
    print(y)
    

    在这里插入图片描述

    3、将之前的state,数组,矩阵合在一起创建一个长度为3的列表。
    # 7 将之前的state,数组,矩阵合在一起创建一个长度为3的列表
    mixList <- list(state,x,y)
    print(mixList)
    

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-i8Cj1caV-1617800863156)(C:\Users\John\AppData\Roaming\Typora\typora-user-images\image-20210407204716283.png)]

    4、创建一个数据框如图。

    在这里插入图片描述

    # 8 创建一个数据框
    rnames <- c("Mazda RX4","Mazda RX4 Wag","Datsun 710","Hornet 4 Drive")
    mpg <- c(21.0,21.0,22.8,21.4)
    cyl <- c(6,6,4,6)
    disp <- c(160.0,160.0,108.0,258.0)
    hp <- c(110,110,93,110)
    drat <- c(3.90,3.90,3.85,3.08)
    mixDataF <- data.frame(row.names=rnames,mpg,cyl,disp,hp,drat)
    print(mixDataF)
    

    在这里插入图片描述

    5、将这个数据框按照mpg列进行排序。
    # 9 将这个数据框按照mpg列进行排序
    ordermixDataF <- mixDataF[order(mixDataF$mpg),]
    print(ordermixDataF)
    

    在这里插入图片描述

    6、访问数据框中drat列值为3.90的数据。
    # 10 访问数据框中drat列值为3.90的数据
    print(subset(mixDataF,drat == 3.90))
    

    在这里插入图片描述

    三、实验要求

    要求熟练掌握向量、矩阵、数据框、列表、因子的创建和使用。

    四、实验总结

    通过对实验过程中重难点进行说明,对实验过程中的缺点不足的阐述,明确以后努力和改进的方向。


    实验二 数据的导入导出

    一、实验目的

    1. 熟练掌握从一些包中读取数据。

    2. 熟练掌握csv文件的导入。

    3. 创建一个数据框,并导出为csv格式。

    二、实验内容

    1、创建一个csv文件(内容自定),并用readtable函数导入该文件。

    手动创建csv文件

    id name gender
    1001 John Male
    1002 yuyu Female
    # 1 用read.table函数导入csv文件
    setwd("D:/bigdata/R语言与数据分析/data06/")
    data = read.table("./Rdata.csv",sep=",")
    print(data)
    

    在这里插入图片描述

    2、查看R语言自带的数据集airquality(纽约1973年5-9月每日空气质量)。
    # 2 查看R语言自带的数据集airquality
    print(airquality)
    

    在这里插入图片描述

    3、列出airquality的前十列,并将这前十列保存到air中。
    # 3 列出airquality的前十列,并将这前十列保存到air中
    air <- airquality[1:10,]
    print(air)
    

    在这里插入图片描述

    4、任选三个列,查看airquality中列的对象类型。
    # 4 查看airquality中列Ozone,Solar.R,Wind的对象类型
    class(airquality$Ozone)
    class(airquality$Solar.R)
    class(airquality$Wind)
    

    在这里插入图片描述

    5、使用names查看airquality数据集中各列的名称
    # 5 使用names查看airquality数据集中各列的名称
    names(airquality)
    

    在这里插入图片描述

    6、将air这个数据框导出为csv格式文件。

    (write.table (x, file ="", sep ="", row.names =TRUE, col.names =TRUE, quote =TRUE))

    # 6 将air这个数据框导出为csv格式文件
    write.table(air, file ="./air.csv" , sep = ",", row.names = FALSE)
    

    在这里插入图片描述

    在这里插入图片描述

    展开全文
  • 当然,大数据分析最核心的,关于数据来源更是至关重要的。 在数据量非常大的今天,如何以更高的效率获取到分析所需要的数据,如何利用这些数据反应最真实的情况,是业内不断探讨的议题。接下来,...

    当我们谈到大数据分析,首先需要确定数据分析的方向和拟解决的问题,然后才能确定需要的数据和分析范围。大数据驱动的分析主要的挑战不是技术问题,而是方向和组织领导的问题,要确定方向,提出问题,需要对行业做深入的了解。当然,大数据分析最核心的,关于数据的来源更是至关重要的。

    在数据量非常大的今天,如何以更高的效率获取到分析所需要的数据,如何利用这些数据反应最真实的情况,是业内不断探讨的议题。接下来,小编就带大家来了解下大数据分析及其数据来源。

    大数据分析:顾名思义,就是对规模巨大的数据进行分析,是研究大量的数据的过程中寻找模式,相关性和其他有用的信息,可以帮助企业更好地适应变化,并做出更明智的决策。

    大数据分析的第一步是数据的“抽取—转换—加载”(the Extract-Transform-Load,ETL),这就是所谓的数据处理三部曲。该环节需要将来源不同、类型不同的数据如关系数据、平面数据文件等抽取出来,然后进行清洁、转换、集成,最后加载到数据仓库或数据集市中,成为联机分析处理、数据挖掘的基础。需要指出的是,尽管大数据分析有它的优势,但是也有很大的局限性。很多时候,大数据产生的相关关系可能是虚假的,在完全随机的数据中显示了某些规律,因为数据的量非常大,可能产生向各个方向辐射的各种联系,有可能会得到与事实完全相反的结论。但是只要数据足够大,数据挖掘总能发现一些相关关系,可以帮助我们发现趋势和异常情况。

    在此我向大家推荐一个大数据开发交流圈:658558542    (☛点击即可加入群聊)里面整理了一大份学习资料,全都是些干货,包括大数据技术入门,大数据离线处理、数据实时处理、Hadoop 、Spark、Flink、推荐系统算法以及源码解析等,送给每一位大数据小伙伴,让自学更轻松。这里不止是小白聚集地,还有大牛在线解答!欢迎初学和进阶中的小伙伴一起进群学习交流,共同进步!

    数据来源

    大数据分析的数据来源有很多种,包括公司或者机构的内部来源和外部来源。分为以下几类:

    1)交易数据。包括POS机数据、信用卡刷卡数据、电子商务数据、互联网点击数据、“企业资源规划”(ERP)系统数据、销售系统数据、客户关系管理(CRM)系统数据、公司的生产数据、库存数据、订单数据、供应链数据等。

    2)移动通信数据。能够上网的智能手机等移动设备越来越普遍。移动通信设备记录的数据量和数据的立体完整度,常常优于各家互联网公司掌握的数据。移动设备上的软件能够追踪和沟通无数事件,从运用软件储存的交易数据(如搜索产品的记录事件)到个人信息资料或状态报告事件(如地点变更即报告一个新的地理编码)等。

    3)人为数据。人为数据包括电子邮件、文档、图片、音频、视频,以及通过微信、博客、推特、维基、脸书、Linkedin等社交媒体产生的数据流。这些数据大多数为非结构性数据,需要用文本分析功能进行分析。

    4)机器和传感器数据。来自感应器、量表和其他设施的数据、定位/GPS系统数据等。这包括功能设备会创建或生成的数据,例如智能温度控制器、智能电表、工厂机器和连接互联网的家用电器的数据。来自新兴的物联网(Io T)的数据是机器和传感器所产生的数据的例子之一。来自物联网的数据可以用于构建分析模型,连续监测预测性行为(如当传感器值表示有问题时进行识别),提供规定的指令(如警示技术人员在真正出问题之前检查设备)等。

    5)互联网上的“开放数据”来源,如政府机构,非营利组织和企业免费提供的数据。

    感谢您的观看,如有不足之处,欢迎批评指正。最后祝福所有遇到瓶颈的大数据程序员们突破自己,祝福大家在往后的工作与面试中一切顺利。

    展开全文
  • 疫情期间找工作确实有点难度,想拿到满意的薪资,确实要点实力啊!面试官:Spring中的@Value用过么,介绍一下我:@Value可以标注在字段上面,可以将外部配置文件中的数据,比如可以...

    疫情期间找工作确实有点难度,想拿到满意的薪资,确实要点实力啊!

    面试官:Spring中的@Value用过么,介绍一下

    我:@Value可以标注在字段上面,可以将外部配置文件中的数据,比如可以将数据库的一些配置信息放在配置文件中,然后通过@Value的方式将其注入到bean的一些字段中

    面试官:那就是说@Value的数据来源于配置文件了?

    我:嗯,我们项目最常用更多就是通过@Value来引用Properties文件中的配置

    面试官:@Value数据来源还有其他方式么?

    我:此时我异常开心,刚好问的我都研究过,我说:当然有,可以将配置信息放在db或者其他存储介质中,容器启动的时候,可以将这些信息加载到Environment中,@Value中应用的值最终是通过Environment来解析的,所以只需要扩展一下Environment就可以实现了。

    面试官:不错嘛,看来你对spring研究的还是可以,是不是喜欢研究spring源码?

    我:笑着说,嗯,平时有空的时候确实喜欢捣鼓捣鼓源码,感觉自己对spring了解的还可以,不能算精通,也算是半精通吧

    面试官:看着我笑了笑,那@Value的注入的值可以动态刷新么?

    我:应该可以吧,我记得springboot中有个@RefreshScope注解就可以实现你说的这个功能

    面试官:那你可以说一下@RefreshScope是如何实现的么,可以大概介绍一下?

    我:嗯。。。这个之前看过一点,不过没有看懂

    面试官:没关系,你可以回去了再研究一下;你期望工资多少?

    我:3万吧

    面试官:今天的面试还算是可以的,不过如果@RefreshScope能回答上来就更好了,这块是个加分项,不过也确实有点难度,2.5万如何?

    我:(心中默默想了想:2.5万,就是一个问题没有回答好,砍了5000,有点狠啊,我要回去再研究研究,3万肯定是没问题的),我说:最低2.9万

    面试官:那谢谢你,今天面试就到这里,出门右拐,不送!

    我有个好习惯,每次面试回去之后,都会进行复盘,把没有搞定的问题一定要想办法搞定,这样才不虚。

    这次面试问题如下

    1. @Value的用法

    2. @Value数据来源

    3. @Value动态刷新的问题

    下面我们一个个来整理一下,将这几个问题搞定,助大家在疫情期间面试能够过关斩将,拿高薪。

    @Value的用法

    系统中需要连接db,连接db有很多配置信息。

    系统中需要发送邮件,发送邮件需要配置邮件服务器的信息。

    还有其他的一些配置信息。

    我们可以将这些配置信息统一放在一个配置文件中,上线的时候由运维统一修改。

    那么系统中如何使用这些配置信息呢,spring中提供了@Value注解来解决这个问题。

    通常我们会将配置信息以key=value的形式存储在properties配置文件中。

    通过@Value("${配置文件中的key}")来引用指定的key对应的value。

    @Value使用步骤

    步骤一:使用@PropertySource注解引入配置文件

    将@PropertySource放在类上面,如下

    @PropertySource({"配置文件路径1","配置文件路径2"...})
    

    @PropertySource注解有个value属性,字符串数组类型,可以用来指定多个配置文件的路径。

    如:

    @Component
    @PropertySource({"classpath:com/javacode2018/lesson002/demo18/db.properties"})
    public class DbConfig {
    }
    

    步骤二:使用@Value注解引用配置文件的值

    通过@Value引用上面配置文件中的值:

    语法

    @Value("${配置文件中的key:默认值}")
    @Value("${配置文件中的key}")
    

    如:

    @Value("${password:123}")
    

    上面如果password不存在,将123作为值

    @Value("${password}")
    

    上面如果password不存在,值为${password}

    假如配置文件如下

    jdbc.url=jdbc:mysql://localhost:3306/javacode2018?characterEncoding=UTF-8
    jdbc.username=javacode
    jdbc.password=javacode
    

    使用方式如下:

    @Value("${jdbc.url}")
    private String url;
    
    @Value("${jdbc.username}")
    private String username;
    
    @Value("${jdbc.password}")
    private String password;
    

    下面来看案例

    案例

    来个配置文件db.properties

    jdbc.url=jdbc:mysql://localhost:3306/javacode2018?characterEncoding=UTF-8
    jdbc.username=javacode
    jdbc.password=javacode
    

    来个配置类,使用@PropertySource引入上面的配置文件

    package com.javacode2018.lesson002.demo18.test1;
    
    import org.springframework.beans.factory.annotation.Configurable;
    import org.springframework.context.annotation.ComponentScan;
    import org.springframework.context.annotation.PropertySource;
    
    @Configurable
    @ComponentScan
    @PropertySource({"classpath:com/javacode2018/lesson002/demo18/db.properties"})
    public class MainConfig1 {
    }
    

    来个类,使用@Value来使用配置文件中的信息

    package com.javacode2018.lesson002.demo18.test1;
    
    import org.springframework.beans.factory.annotation.Value;
    import org.springframework.stereotype.Component;
    
    @Component
    public class DbConfig {
    
        @Value("${jdbc.url}")
        private String url;
    
        @Value("${jdbc.username}")
        private String username;
    
        @Value("${jdbc.password}")
        private String password;
    
        public String getUrl() {
            return url;
        }
    
        public void setUrl(String url) {
            this.url = url;
        }
    
        public String getUsername() {
            return username;
        }
    
        public void setUsername(String username) {
            this.username = username;
        }
    
        public String getPassword() {
            return password;
        }
    
        public void setPassword(String password) {
            this.password = password;
        }
    
        @Override
        public String toString() {
            return "DbConfig{" +
                    "url='" + url + '\'' +
                    ", username='" + username + '\'' +
                    ", password='" + password + '\'' +
                    '}';
        }
    }
    

    上面重点在于注解@Value注解,注意@Value注解中的

    来个测试用例

    package com.javacode2018.lesson002.demo18;
    
    import com.javacode2018.lesson002.demo18.test1.DbConfig;
    import com.javacode2018.lesson002.demo18.test1.MainConfig1;
    import org.junit.Test;
    import org.springframework.context.annotation.AnnotationConfigApplicationContext;
    
    public class ValueTest {
    
        @Test
        public void test1() {
            AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
            context.register(MainConfig1.class);
            context.refresh();
    
            DbConfig dbConfig = context.getBean(DbConfig.class);
            System.out.println(dbConfig);
        }
    }
    

    运行输出

    DbConfig{url='jdbc:mysql://localhost:3306/javacode2018?characterEncoding=UTF-8', username='javacode', password='javacode'}
    

    上面用起来比较简单,很多用过的人看一眼就懂了,这也是第一个问题,多数人都是ok的,下面来看@Value中数据来源除了配置文件的方式,是否还有其他方式。

    @Value数据来源

    通常情况下我们@Value的数据来源于配置文件,不过,还可以用其他方式,比如我们可以将配置文件的内容放在数据库,这样修改起来更容易一些。

    我们需要先了解一下@Value中数据来源于spring的什么地方。

    spring中有个类

    org.springframework.core.env.PropertySource
    

    可以将其理解为一个配置源,里面包含了key->value的配置信息,可以通过这个类中提供的方法获取key对应的value信息

    内部有个方法:

    public abstract Object getProperty(String name);
    

    通过name获取对应的配置信息。

    系统有个比较重要的接口

    org.springframework.core.env.Environment
    

    用来表示环境配置信息,这个接口有几个方法比较重要

    String resolvePlaceholders(String text);
    MutablePropertySources getPropertySources();
    

    resolvePlaceholders用来解析${text}的,@Value注解最后就是调用这个方法来解析的。

    getPropertySources返回MutablePropertySources对象,来看一下这个类

    public class MutablePropertySources implements PropertySources {
    
        private final List<PropertySource<?>> propertySourceList = new CopyOnWriteArrayList<>();
    
    }
    

    内部包含一个propertySourceList列表。

    spring容器中会有一个Environment对象,最后会调用这个对象的resolvePlaceholders方法解析@Value。

    大家可以捋一下,最终解析@Value的过程:

    1. 将@Value注解的value参数值作为Environment.resolvePlaceholders方法参数进行解析
    2. Environment内部会访问MutablePropertySources来解析
    3. MutablePropertySources内部有多个PropertySource,此时会遍历PropertySource列表,调用PropertySource.getProperty方法来解析key对应的值
    

    通过上面过程,如果我们想改变@Value数据的来源,只需要将配置信息包装为PropertySource对象,丢到Environment中的MutablePropertySources内部就可以了。

    下面我们就按照这个思路来一个。

    来个邮件配置信息类,内部使用@Value注入邮件配置信息

    package com.javacode2018.lesson002.demo18.test2;
    
    import org.springframework.beans.factory.annotation.Value;
    import org.springframework.stereotype.Component;
    
    /**
     * 邮件配置信息
     */
    @Component
    public class MailConfig {
    
        @Value("${mail.host}")
        private String host;
    
        @Value("${mail.username}")
        private String username;
    
        @Value("${mail.password}")
        private String password;
    
        public String getHost() {
            return host;
        }
    
        public void setHost(String host) {
            this.host = host;
        }
    
        public String getUsername() {
            return username;
        }
    
        public void setUsername(String username) {
            this.username = username;
        }
    
        public String getPassword() {
            return password;
        }
    
        public void setPassword(String password) {
            this.password = password;
        }
    
        @Override
        public String toString() {
            return "MailConfig{" +
                    "host='" + host + '\'' +
                    ", username='" + username + '\'' +
                    ", password='" + password + '\'' +
                    '}';
        }
    }
    

    再来个类DbUtilgetMailInfoFromDb方法模拟从db中获取邮件配置信息,存放在map中

    package com.javacode2018.lesson002.demo18.test2;
    
    import java.util.HashMap;
    import java.util.Map;
    
    public class DbUtil {
        /**
         * 模拟从db中获取邮件配置信息
         *
         * @return
         */
        public static Map<String, Object> getMailInfoFromDb() {
            Map<String, Object> result = new HashMap<>();
            result.put("mail.host", "smtp.qq.com");
            result.put("mail.username", "路人");
            result.put("mail.password", "123");
            return result;
        }
    }
    

    来个spring配置类

    package com.javacode2018.lesson002.demo18.test2;
    
    import org.springframework.context.annotation.ComponentScan;
    import org.springframework.context.annotation.Configuration;
    
    @Configuration
    @ComponentScan
    public class MainConfig2 {
    }
    

    下面是重点代码

    @Test
    public void test2() {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
    
        /*下面这段是关键 start*/
        //模拟从db中获取配置信息
        Map<String, Object> mailInfoFromDb = DbUtil.getMailInfoFromDb();
        //将其丢在MapPropertySource中(MapPropertySource类是spring提供的一个类,是PropertySource的子类)
        MapPropertySource mailPropertySource = new MapPropertySource("mail", mailInfoFromDb);
        //将mailPropertySource丢在Environment中的PropertySource列表的第一个中,让优先级最高
        context.getEnvironment().getPropertySources().addFirst(mailPropertySource);
        /*上面这段是关键 end*/
    
        context.register(MainConfig2.class);
        context.refresh();
        MailConfig mailConfig = context.getBean(MailConfig.class);
        System.out.println(mailConfig);
    }
    

    注释比较详细,就不详细解释了。

    直接运行,看效果

    MailConfig{host='smtp.qq.com', username='路人', password='123'}
    

    有没有感觉很爽,此时你们可以随意修改DbUtil.getMailInfoFromDb,具体数据是从db中来,来时从redis或者其他介质中来,任由大家发挥。

    上面重点是下面这段代码,大家需要理解

    /*下面这段是关键 start*/
    //模拟从db中获取配置信息
    Map<String, Object> mailInfoFromDb = DbUtil.getMailInfoFromDb();
    //将其丢在MapPropertySource中(MapPropertySource类是spring提供的一个类,是PropertySource的子类)
    MapPropertySource mailPropertySource = new MapPropertySource("mail", mailInfoFromDb);
    //将mailPropertySource丢在Environment中的PropertySource列表的第一个中,让优先级最高
    context.getEnvironment().getPropertySources().addFirst(mailPropertySource);
    /*上面这段是关键 end*/
    

    咱们继续看下一个问题

    如果我们将配置信息放在db中,可能我们会通过一个界面来修改这些配置信息,然后保存之后,希望系统在不重启的情况下,让这些值在spring容器中立即生效。

    @Value动态刷新的问题的问题,springboot中使用@RefreshScope实现了。

    实现@Value动态刷新

    先了解一个知识点

    这块需要先讲一个知识点,用到的不是太多,所以很多人估计不太了解,但是非常重要的一个点,我们来看一下。

    这个知识点是自定义bean作用域,对这块不了解的先看一下这篇文章:bean作用域详解

    bean作用域中有个地方没有讲,来看一下@Scope这个注解的源码,有个参数是:

    ScopedProxyMode proxyMode() default ScopedProxyMode.DEFAULT;
    

    这个参数的值是个ScopedProxyMode类型的枚举,值有下面4中

    public enum ScopedProxyMode {
        DEFAULT,
        NO,
        INTERFACES,
        TARGET_CLASS;
    }
    

    前面3个,不讲了,直接讲最后一个值是干什么的。

    当@Scope中proxyMode为TARGET_CLASS的时候,会给当前创建的bean通过cglib生成一个代理对象,通过这个代理对象来访问目标bean对象。

    理解起来比较晦涩,还是来看代码吧,容易理解一些,来个自定义的Scope案例。

    自定义一个bean作用域的注解

    package com.javacode2018.lesson002.demo18.test3;
    
    import org.springframework.context.annotation.Scope;
    import org.springframework.context.annotation.ScopedProxyMode;
    
    import java.lang.annotation.*;
    
    @Target({ElementType.TYPE, ElementType.METHOD})
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    @Scope(BeanMyScope.SCOPE_MY) //@1
    public @interface MyScope {
        /**
         * @see Scope#proxyMode()
         */
        ScopedProxyMode proxyMode() default ScopedProxyMode.TARGET_CLASS;//@2
    }
    

    @1:使用了@Scope注解,value为引用了一个常量,值为my,一会下面可以看到。

    @2:注意这个地方,参数名称也是proxyMode,类型也是ScopedProxyMode,而@Scope注解中有个和这个同样类型的参数,spring容器解析的时候,会将这个参数的值赋给@MyScope注解上面的@Scope注解的proxyMode参数,所以此处我们设置proxyMode值,最后的效果就是直接改变了@Scope中proxyMode参数的值。此处默认值取的是ScopedProxyMode.TARGET_CLASS

    @MyScope注解对应的Scope实现如下

    package com.javacode2018.lesson002.demo18.test3;
    
    import org.springframework.beans.factory.ObjectFactory;
    import org.springframework.beans.factory.config.Scope;
    import org.springframework.lang.Nullable;
    
    /**
     * @see MyScope 作用域的实现
     */
    public class BeanMyScope implements Scope {
    
        public static final String SCOPE_MY = "my"; //@1
    
        @Override
        public Object get(String name, ObjectFactory<?> objectFactory) { 
            System.out.println("BeanMyScope >>>>>>>>> get:" + name); //@2
            return objectFactory.getObject(); //@3
        }
    
        @Nullable
        @Override
        public Object remove(String name) {
            return null;
        }
    
        @Override
        public void registerDestructionCallback(String name, Runnable callback) {
    
        }
    
        @Nullable
        @Override
        public Object resolveContextualObject(String key) {
            return null;
        }
    
        @Nullable
        @Override
        public String getConversationId() {
            return null;
        }
    }
    

    @1:定义了一个常量,作为作用域的值

    @2:这个get方法是关键,自定义作用域会自动调用这个get方法来创建bean对象,这个地方输出了一行日志,为了一会方便看效果

    @3:通过objectFactory.getObject()获取bean实例返回。

    下面来创建个类,作用域为上面自定义的作用域

    package com.javacode2018.lesson002.demo18.test3;
    
    import org.springframework.stereotype.Component;
    
    import java.util.UUID;
    
    @Component
    @MyScope //@1 
    public class User {
    
        private String username;
    
        public User() { 
            System.out.println("---------创建User对象" + this); //@2
            this.username = UUID.randomUUID().toString(); //@3
        }
    
        public String getUsername() {
            return username;
        }
    
        public void setUsername(String username) {
            this.username = username;
        }
    
    }
    

    @1:使用了自定义的作用域@MyScope

    @2:构造函数中输出一行日志

    @3:给username赋值,通过uuid随机生成了一个

    来个spring配置类,加载上面@Compontent标注的组件

    package com.javacode2018.lesson002.demo18.test3;
    
    import org.springframework.context.annotation.ComponentScan;
    import org.springframework.context.annotation.Configuration;
    
    @ComponentScan
    @Configuration
    public class MainConfig3 {
    }
    

    下面重点来了,测试用例

    @Test
    public void test3() throws InterruptedException {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
        //将自定义作用域注册到spring容器中
        context.getBeanFactory().registerScope(BeanMyScope.SCOPE_MY, new BeanMyScope());//@1
        context.register(MainConfig3.class);
        context.refresh();
    
        System.out.println("从容器中获取User对象");
        User user = context.getBean(User.class); //@2
        System.out.println("user对象的class为:" + user.getClass()); //@3
    
        System.out.println("多次调用user的getUsername感受一下效果\n");
        for (int i = 1; i <= 3; i++) {
            System.out.println(String.format("********\n第%d次开始调用getUsername", i));
            System.out.println(user.getUsername());
            System.out.println(String.format("第%d次调用getUsername结束\n********\n", i));
        }
    }
    

    @1:将自定义作用域注册到spring容器中

    @2:从容器中获取User对应的bean

    @3:输出这个bean对应的class,一会认真看一下,这个类型是不是User类型的

    代码后面又搞了3次循环,调用user的getUsername方法,并且方法前后分别输出了一行日志。

    见证奇迹的时候到了,运行输出

    从容器中获取User对象
    user对象的class为:class com.javacode2018.lesson002.demo18.test3.User$$EnhancerBySpringCGLIB$$80233127
    多次调用user的getUsername感受一下效果
    
    ********
    第1次开始调用getUsername
    BeanMyScope >>>>>>>>> get:scopedTarget.user
    ---------创建User对象com.javacode2018.lesson002.demo18.test3.User@6a370f4
    7b41aa80-7569-4072-9d40-ec9bfb92f438
    第1次调用getUsername结束
    ********
    
    ********
    第2次开始调用getUsername
    BeanMyScope >>>>>>>>> get:scopedTarget.user
    ---------创建User对象com.javacode2018.lesson002.demo18.test3.User@1613674b
    01d67154-95f6-44bb-93ab-05a34abdf51f
    第2次调用getUsername结束
    ********
    
    ********
    第3次开始调用getUsername
    BeanMyScope >>>>>>>>> get:scopedTarget.user
    ---------创建User对象com.javacode2018.lesson002.demo18.test3.User@27ff5d15
    76d0e86f-8331-4303-aac7-4acce0b258b8
    第3次调用getUsername结束
    ********
    

    从输出的前2行可以看出:

    1. 调用context.getBean(User.class)从容器中获取bean的时候,此时并没有调用User的构造函数去创建User对象

    2. 第二行输出的类型可以看出,getBean返回的user对象是一个cglib代理对象。

    后面的日志输出可以看出,每次调用user.getUsername方法的时候,内部自动调用了BeanMyScope#get 方法和 User的构造函数。

    通过上面的案例可以看出,当自定义的Scope中proxyMode=ScopedProxyMode.TARGET_CLASS的时候,会给这个bean创建一个代理对象,调用代理对象的任何方法,都会调用这个自定义的作用域实现类(上面的BeanMyScope)中get方法来重新来获取这个bean对象。

    动态刷新@Value具体实现

    那么我们可以利用上面讲解的这种特性来实现@Value的动态刷新,可以实现一个自定义的Scope,这个自定义的Scope支持@Value注解自动刷新,需要使用@Value注解自动刷新的类上面可以标注这个自定义的注解,当配置修改的时候,调用这些bean的任意方法的时候,就让spring重启初始化一下这个bean,这个思路就可以实现了,下面我们来写代码。

    先来自定义一个Scope:RefreshScope

    package com.javacode2018.lesson002.demo18.test4;
    
    import org.springframework.context.annotation.Scope;
    import org.springframework.context.annotation.ScopedProxyMode;
    
    import java.lang.annotation.*;
    
    @Target({ElementType.TYPE, ElementType.METHOD})
    @Retention(RetentionPolicy.RUNTIME)
    @Scope(BeanRefreshScope.SCOPE_REFRESH)
    @Documented
    public @interface RefreshScope {
        ScopedProxyMode proxyMode() default ScopedProxyMode.TARGET_CLASS; //@1
    }
    

    要求标注@RefreshScope注解的类支持动态刷新@Value的配置

    @1:这个地方是个关键,使用的是ScopedProxyMode.TARGET_CLASS

    这个自定义Scope对应的解析类

    下面类中有几个无关的方法去掉了,可以忽略

    package com.javacode2018.lesson002.demo18.test4;
    
    
    import org.springframework.beans.factory.ObjectFactory;
    import org.springframework.beans.factory.config.Scope;
    import org.springframework.lang.Nullable;
    
    import java.util.concurrent.ConcurrentHashMap;
    
    public class BeanRefreshScope implements Scope {
    
        public static final String SCOPE_REFRESH = "refresh";
    
        private static final BeanRefreshScope INSTANCE = new BeanRefreshScope();
    
        //来个map用来缓存bean
        private ConcurrentHashMap<String, Object> beanMap = new ConcurrentHashMap<>(); //@1
    
        private BeanRefreshScope() {
        }
    
        public static BeanRefreshScope getInstance() {
            return INSTANCE;
        }
    
        /**
         * 清理当前
         */
        public static void clean() {
            INSTANCE.beanMap.clear();
        }
    
        @Override
        public Object get(String name, ObjectFactory<?> objectFactory) {
            Object bean = beanMap.get(name);
            if (bean == null) {
                bean = objectFactory.getObject();
                beanMap.put(name, bean);
            }
            return bean;
        }
    
    }
    

    上面的get方法会先从beanMap中获取,获取不到会调用objectFactory的getObject让spring创建bean的实例,然后丢到beanMap中

    上面的clean方法用来清理beanMap中当前已缓存的所有bean

    来个邮件配置类,使用@Value注解注入配置,这个bean作用域为自定义的@RefreshScope

    package com.javacode2018.lesson002.demo18.test4;
    
    import org.springframework.beans.factory.annotation.Value;
    import org.springframework.stereotype.Component;
    
    /**
     * 邮件配置信息
     */
    @Component
    @RefreshScope //@1
    public class MailConfig {
    
        @Value("${mail.username}") //@2
        private String username;
    
        public String getUsername() {
            return username;
        }
    
        public void setUsername(String username) {
            this.username = username;
        }
    
        @Override
        public String toString() {
            return "MailConfig{" +
                    "username='" + username + '\'' +
                    '}';
        }
    }
    

    @1:使用了自定义的作用域@RefreshScope

    @2:通过@Value注入mail.username对一个的值

    重写了toString方法,一会测试时候可以看效果。

    再来个普通的bean,内部会注入MailConfig

    package com.javacode2018.lesson002.demo18.test4;
    
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Component;
    
    @Component
    public class MailService {
        @Autowired
        private MailConfig mailConfig;
    
        @Override
        public String toString() {
            return "MailService{" +
                    "mailConfig=" + mailConfig +
                    '}';
        }
    }
    

    代码比较简单,重写了toString方法,一会测试时候可以看效果。

    来个类,用来从db中获取邮件配置信息

    package com.javacode2018.lesson002.demo18.test4;
    
    import java.util.HashMap;
    import java.util.Map;
    import java.util.UUID;
    
    public class DbUtil {
        /**
         * 模拟从db中获取邮件配置信息
         *
         * @return
         */
        public static Map<String, Object> getMailInfoFromDb() {
            Map<String, Object> result = new HashMap<>();
            result.put("mail.username", UUID.randomUUID().toString());
            return result;
        }
    }
    

    来个spring配置类,扫描加载上面的组件

    package com.javacode2018.lesson002.demo18.test4;
    
    import org.springframework.context.annotation.ComponentScan;
    import org.springframework.context.annotation.Configuration;
    
    @Configuration
    @ComponentScan
    public class MainConfig4 {
    }
    

    来个工具类

    内部有2个方法,如下:

    package com.javacode2018.lesson002.demo18.test4;
    
    import org.springframework.context.support.AbstractApplicationContext;
    import org.springframework.core.env.MapPropertySource;
    
    import java.util.Map;
    
    public class RefreshConfigUtil {
        /**
         * 模拟改变数据库中都配置信息
         */
        public static void updateDbConfig(AbstractApplicationContext context) {
            //更新context中的mailPropertySource配置信息
            refreshMailPropertySource(context);
    
            //清空BeanRefreshScope中所有bean的缓存
            BeanRefreshScope.getInstance().clean();
        }
    
        public static void refreshMailPropertySource(AbstractApplicationContext context) {
            Map<String, Object> mailInfoFromDb = DbUtil.getMailInfoFromDb();
            //将其丢在MapPropertySource中(MapPropertySource类是spring提供的一个类,是PropertySource的子类)
            MapPropertySource mailPropertySource = new MapPropertySource("mail", mailInfoFromDb);
            context.getEnvironment().getPropertySources().addFirst(mailPropertySource);
        }
    
    }
    

    updateDbConfig方法模拟修改db中配置的时候需要调用的方法,方法中2行代码,第一行代码调用refreshMailPropertySource方法修改容器中邮件的配置信息

    BeanRefreshScope.getInstance().clean()用来清除BeanRefreshScope中所有已经缓存的bean,那么调用bean的任意方法的时候,会重新出发spring容器来创建bean,spring容器重新创建bean的时候,会重新解析@Value的信息,此时容器中的邮件配置信息是新的,所以@Value注入的信息也是新的。

    来个测试用例

    @Test
    public void test4() throws InterruptedException {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
        context.getBeanFactory().registerScope(BeanRefreshScope.SCOPE_REFRESH, BeanRefreshScope.getInstance());
        context.register(MainConfig4.class);
        //刷新mail的配置到Environment
        RefreshConfigUtil.refreshMailPropertySource(context);
        context.refresh();
    
        MailService mailService = context.getBean(MailService.class);
        System.out.println("配置未更新的情况下,输出3次");
        for (int i = 0; i < 3; i++) { //@1
            System.out.println(mailService);
            TimeUnit.MILLISECONDS.sleep(200);
        }
    
        System.out.println("模拟3次更新配置效果");
        for (int i = 0; i < 3; i++) { //@2
            RefreshConfigUtil.updateDbConfig(context); //@3
            System.out.println(mailService);
            TimeUnit.MILLISECONDS.sleep(200);
        }
    }
    

    @1:循环3次,输出mailService的信息

    @2:循环3次,内部先通过@3来模拟更新db中配置信息,然后在输出mailService信息

    见证奇迹的时刻,来看效果

    配置未更新的情况下,输出3次
    MailService{mailConfig=MailConfig{username='df321543-8ca7-4563-993a-bd64cbf50d53'}}
    MailService{mailConfig=MailConfig{username='df321543-8ca7-4563-993a-bd64cbf50d53'}}
    MailService{mailConfig=MailConfig{username='df321543-8ca7-4563-993a-bd64cbf50d53'}}
    模拟3次更新配置效果
    MailService{mailConfig=MailConfig{username='6bab8cea-9f4f-497d-a23a-92f15d0d6e34'}}
    MailService{mailConfig=MailConfig{username='581bf395-f6b8-4b87-84e6-83d3c7342ca2'}}
    MailService{mailConfig=MailConfig{username='db337f54-20b0-4726-9e55-328530af6999'}}
    

    上面MailService输出了6次,前3次username的值都是一样的,后面3次username的值不一样了,说明修改配置起效了。

    小结

    动态@Value实现的关键是@Scope中proxyMode参数,值为ScopedProxyMode.DEFAULT,会生成一个代理,通过这个代理来实现@Value动态刷新的效果,这个地方是关键。

    有兴趣的可以去看一下springboot中的@RefreshScope注解源码,和我们上面自定义的@RefreshScope类似,实现原理类似的。

    总结

    本次面试过程中3个问题,我们都搞定了,希望你也已经掌握了,有问题的欢迎给我留言,交流!

    案例源码

    https://gitee.com/javacode2018/spring-series
    

    路人甲java所有案例代码以后都会放到这个上面,大家watch一下,可以持续关注动态。

    Spring系列

    1. Spring系列第1篇:为何要学spring?

    2. Spring系列第2篇:控制反转(IoC)与依赖注入(DI)

    3. Spring系列第3篇:Spring容器基本使用及原理

    4. Spring系列第4篇:xml中bean定义详解(-)

    5. Spring系列第5篇:创建bean实例这些方式你们都知道?

    6. Spring系列第6篇:玩转bean scope,避免跳坑里!

    7. Spring系列第7篇:依赖注入之手动注入

    8. Spring系列第8篇:自动注入(autowire)详解,高手在于坚持

    9. Spring系列第9篇:depend-on到底是干什么的?

    10. Spring系列第10篇:primary可以解决什么问题?

    11. Spring系列第11篇:bean中的autowire-candidate又是干什么的?

    12. Spring系列第12篇:lazy-init:bean延迟初始化

    13. Spring系列第13篇:使用继承简化bean配置(abstract & parent)

    14. Spring系列第14篇:lookup-method和replaced-method比较陌生,怎么玩的?

    15. Spring系列第15篇:代理详解(Java动态代理&cglib代理)?

    16. Spring系列第16篇:深入理解java注解及spring对注解的增强(预备知识)

    17. Spring系列第17篇:@Configration和@Bean注解详解(bean批量注册)

    18. Spring系列第18篇:@ComponentScan、@ComponentScans详解(bean批量注册)

    19. Spring系列第18篇:@import详解(bean批量注册)

    20. Spring系列第20篇:@Conditional通过条件来控制bean的注册

    21. Spring系列第21篇:注解实现依赖注入(@Autowired、@Resource、@Primary、@Qulifier)

    22. Spring系列第22篇:@Scope、@DependsOn、@ImportResource、@Lazy 详解

    23. Spring系列第23篇:Bean生命周期详解

    24. Spring系列第24篇:父子容器详解

    更多好文章

    1. Java高并发系列(共34篇)

    2. MySql高手系列(共27篇)

    3. Maven高手系列(共10篇)

    4. Mybatis系列(共12篇)

    5. 聊聊db和缓存一致性常见的实现方式

    6. 接口幂等性这么重要,它是什么?怎么实现?

    7. 泛型,有点难度,会让很多人懵逼,那是因为你没有看这篇文章!

    感谢大家的阅读,也欢迎您把这篇文章分享给更多的朋友一起阅读!谢谢!

    路人甲java

    ▲长按图片识别二维码关注

    路人甲Java:工作10年的前阿里P7分享Java、算法、数据库方面的技术干货!坚信用技术改变命运,让家人过上更体面的生活!

    展开全文
  • Spark-Sql创建多数据源...1、Spark-Sql数据来源有多种,Hive,Kakfa,RDD及关系库等。 2、注册临时表与关系库映射表的join实现,核心思想就是,Hive和关系库的数据,分别加载出来做成dataframe,然后分别注册成临时表。
  • 很遗憾的是,中国法律的限制,ESRI 没有办法向用户 直接提供数据,更要命的,国内数据来源广泛,没有统一的标准,很多公司都数据的测绘资质,比较大的数据厂商四维、高德等还比较规范,但是很多并非专业的 数据...
  • 机器学习数据来源

    千次阅读 2015-02-14 11:40:32
    C Irvine Machine Learning Repository:UCI指的是加州大学欧文分校。...自那时以来,它已被广泛用于学生,教育工作者,和其他研究机器学习的研究者,作为一个数据来源。 UCI数据集 的说明 告诉了读者
  • 数据集的创建(digits)

    千次阅读 2018-09-26 10:22:05
    数据集的构建(digits) 数据集的选择 Digits提供多种数据集的创建,包括图片分类、目标检测、图像分割和其他类的数据集。...数据集的来源。 包括三种方式,制定文件夹方式、上传文件方式和s3...
  • JDBC 动态创建数据表 及 SQL预处理

    千次阅读 2015-03-05 08:25:51
    这两天由于公司的需求,客户需要自定义数据表的字段,导致每张表的字段都不是固定的而且很难一个通用的模板去维护,所以就使用JDBC动态去创建数据表,然后通过表的字段动态添加数据,数据的来源主要是用户提供的...
  • mysql 动态创建表、添加数据

    千次阅读 2017-02-24 19:51:23
    在数据库test中创建数据表CREATE TABLE salestotal ( user_id int(8) not null, name varchar(50), englishname varchar(50), totalsales decimal(5,2), PRIMARY KEY (user_id) );然后可以使用嵌套INSERT INTO...
  • 比如:从另一个数据库的表中查询数据插入到这张表  INSERT INTO dbo.userInfo  (ID,UserName,Age)  SELECT ID,UserName,Age  FROM anotherDatabase.user 比如:自动生成10个GUID插入到这张表  INSERT ...
  • 【PB】数据窗口Grid创建及使用

    千次阅读 热门讨论 2017-06-26 21:40:11
    PB程序中数据窗口Grid的创建及使用简要介绍。
  • SQL语句创建表并添加数据

    千次阅读 2017-02-28 21:12:30
    SQL语句创建表并添加数据创建表use school 指定要用的数据库 go create table student 创建表 ( ID bigint identity(1,1), 添加ID,identity(标识种子,递增量) name varchar(10) not null, 添加姓名 sex char(2...
  • hive 创建表、加载数据 load data

    万次阅读 2018-09-13 16:43:26
    一、 创建表   在官方的wiki里,example是这样的: CREATE [EXTERNAL] TABLE [IF NOT EXISTS] table_name [(col_name data_type [COMMENT col_comment], ...)] [COMMENT table_comment] [PARTITIONED BY ...
  • Hive HQL数据操作、数据查询

    千次阅读 2017-05-08 14:21:05
    一、HQL 数据操作1.装载数据LOAD DATA INPATH '/user/hadoop/o' INTO TABLE test;如果test表是一个分区表,则在HQL中指定区分:LOAD DATA INPATH '/USER/HADOOP/O' OVERWRITE INTO TABLE test3 PARTITION(part="a");...
  • HBase shell 命令创建表及添加数据操作 创建表,表名hbase_test,HBase表是由Key-Value组成的,下面给出一个hbase表的格式,方便小伙伴们理解 此表两个列族,列族1和列族2,其中列族1和列族2下分别两个列name...
  •  ①建立一个ArcMap文档,ArcMap里面的数据来源是从上面建立好的网络集跟拓扑差错后的道路图层获取的,如下:  ②地图服务基础上,勾中Network Analysis选项。  ③输入路网服务的URL之后,出现如下: ...
  • iReport用javabean创建数据

    万次阅读 2012-12-10 11:56:15
    1、创建一个javabean对象 import java.io.Serializable; public class GoodPrint implements Serializable{ /** *  */ private static final long serialVersionUID = 1L; private String goodName; ...
  • mysql创建字段选数据类型参考大全

    千次阅读 2016-06-26 15:32:27
    数据类型 上限 数据类型说明  日期和时间数据类型   date 3字节 日期,格式:2014-09-18 日期和时间数据类型   time 3字节 时间,格式:08...
  • Grafana是一款采用 go 语言编写的开源应用,主要用于大规模指标数据的可视化展现,是网络架构和应用分析中最流行的时序数据展示工具,目前已经支持绝大部分常用的时序数据库。 官网 操作文档 grafana安装 经常被用作...
  • 入门学习一周,开始写学习笔记。用习惯R之后,发现SAS程序相对python R还是有点繁杂。但是业务需要,不得不学一下。 一、逻辑库、数据集、数据...数据集,包括数据文件+SAS视图,可以像R中双击获取数据结构图表,不
  • MySQL查询某天(内)的数据

    千次阅读 2019-08-28 14:45:30
    使用DATED欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题,助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右...
  • 数据结构(C语言)线性表的创建、插入、删除等操作 #include&amp;amp;lt;stdio.h&amp;amp;gt; #include&amp;amp;lt;stdlib.h&amp;amp;gt; #define TRUE 1; #define FALSE 0; #define OK 1; #...
  • 写这个东西写的我万分痛苦,因为这么...首先说查询吧: 一般我们做android应用都会考虑做一些测试数据,测试数据一般都是手工insert数据库的, 由于sqlite3采用的字符集是GB2312,因此我们每次插入的数据在通过sqlite
  • SQ01 快速创建SAP查询报表

    千次阅读 2011-12-05 14:15:53
    一,Query 无需编程在SAP中利用查询创建各种报表; 创建时,自带各种功能:比如:分类汇总,小计,特别标示..... 二, 增加计算栏位; 如特殊需求,可以增加一些栏位,用来存放中间计算结果 三, Query 转成Tcode;  创建...
  • hive内部表外部表的创建及load数据

    千次阅读 2018-10-09 14:43:50
    创建hive内部表 create table test_01(id bigint, name string ) row format delimited fields terminated by ','; 默认记录和字段分隔符: \n 每行一条记录 ^A 分隔列(八进制 \001) ^B 分隔ARRAY或者...
  • 海量数据的存储计算和查询模型

    千次阅读 2013-07-16 17:08:21
    而今天,各种社交网络,移动应用以及各种传感器和科学领域每天创建着上PB的数据。 为了应对这种大规模数据处理的挑战,google创造了MapReduce。Google的工作以及yahoo创建的Hadoop孵化出一个完整的海量数据处理工具...
  • 数据仓库多维数据模型设计

    万次阅读 2017-11-09 18:14:59
    这里我们将要详细介绍如何创建适合自己的数据模型。 数据仓库建模方法 大千世界,表面看五彩缤纷,实质上,万物都遵循其自有的法则。 数据仓库的建模方法同样也很多种,每一种建模方法其实代表了哲学上的一个...
  • UCI数据集整理(附论文常用数据集)

    万次阅读 多人点赞 2018-08-30 18:02:32
    摘要:UCI数据集作为标准测试数据集经常出现在许多机器学习的论文中,为了更方便使用这些数据必要对其进行整理,这里整理了论文中经常出现的数据集,并详细介绍如何使用MATLAB将数据集文件整理成自己需要的格式...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 376,483
精华内容 150,593
关键字:

创建查询的数据来源有