Spark framework to mysql

最新推荐文章于 2022-11-16 10:16:37 发布
最新推荐文章于 2022-11-16 10:16:37 发布
阅读量847 收藏
点赞数 1
文章标签： mysql spark 数据库 框架
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xuzhaoji0405/article/details/71195041
版权

官网，建立一个小型的framework去连接数据库sql2o

在此处我讲讲解怎么用spark framework这个小型的微框架（麻雀虽小，五脏俱全，这个框架能完成网页全部最基本的操作，但是它的所占的空间是是很小的）连接到本机的mysql上，是对官方代码的修改，同时对官网的设计方法做出个人的分析。
orm（对象关系映射）是一种设计方法，说的是怎么在对象和数据库中数据的存储之间建立一套完整的操作机制。一句话概括O R M 技术是在对象和关系之间提供了一条桥梁，前台的对象型数据和数据库中的关系型的数据通过这个桥梁来相互转。

首先是依赖关系，即用maven打包必须需要用到的pom.xml文件，用来下载相关的依赖，使得在程序中调用到的类能正常载入使用。

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>me.tomassetti</groupId>
    <artifactId>BlogService</artifactId>
    <packaging>jar</packaging>
    <version>1.0-SNAPSHOT</version>
    <name>BlogService</name>
    <url>http://maven.apache.org</url>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>com.sparkjava</groupId>
            <artifactId>spark-core</artifactId>
            <version>2.3</version>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-core</artifactId>
            <version>2.6.4</version>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>2.6.4</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.16.6</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>org.sql2o</groupId>
            <artifactId>sql2o</artifactId>
            <version>1.5.4</version>
        </dependency>
        <dependency>
            <groupId>org.postgresql</groupId>
            <artifactId>postgresql</artifactId>
            <version>9.4-1206-jdbc42</version>
        </dependency>
        <dependency>
            <groupId>com.google.guava</groupId>
            <artifactId>guava</artifactId>
            <version>19.0</version>
        </dependency>
        <dependency>
            <groupId>org.easymock</groupId>
            <artifactId>easymock</artifactId>
            <version>3.4</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>com.google.code.gson</groupId>
            <artifactId>gson</artifactId>
            <version>2.5</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>com.beust</groupId>
            <artifactId>jcommander</artifactId>
            <version>1.48</version>
        </dependency>
        <dependency>
            <groupId>com.sparkjava</groupId>
            <artifactId>spark-template-freemarker</artifactId>
            <version>2.3</version>
        </dependency>
        <dependency>
            <groupId>com.j2html</groupId>
            <artifactId>j2html</artifactId>
            <version>0.7</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.2</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                    <encoding>${project.build.sourceEncoding}</encoding>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.codehaus.mojo</groupId>
                <artifactId>exec-maven-plugin</artifactId>
                <version>1.2.1</version>
                <configuration>
                    <mainClass>me.tomassetti.BlogService</mainClass>
                    <arguments>
                    </arguments>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

最后的build内容是打包类建立文件时必须加入的，如果缺少，则Maven Compile插件默认会加-source 1.5以及target -1.5来参数编译（估计是为了兼容一些老的Linux服务器操作系统，它们通常只有JDK 5），而由于我们的代码里用了JDK 7/8的语法，因此需用更改默认的属性。，需要加入在properties里面加入代码

<properties>
      <maven.compiler.source>1.8</maven.compiler.source>
      <maven.compiler.target>1.8</maven.compiler.target>
    </properties>

前期准备：
需要在本机的数据库中建立名字为blog数据库（当然可以自己变），
然后新建相关的表；


create database blog;
create table posts(post_uuid char(50) primary key,title text not null, content text,publishing_data date);

create table comments(comment_uuid char(50) primary key,post_uuid char(50) posts(post_uuid),author text,content text,approved bool,submission_data date);

create table post_categories(post_uuid char(50) references post(post_uuid),category text);

此处的UUID我用的是char(50)，来存，因为mysql中并没有UUID类型，而我开始的时候也考虑了，如果我在对象中用的是String类型，那么存取的时候是否能匹配UUID一致？经过实验后答案是肯定的，我们可以用String类型来匹配mysql中的char（）和text类型。

代码的介绍说明

相关包的载入

import com.beust.jcommander.JCommander;
import freemarker.cache.ClassTemplateLoader;
import freemarker.template.Configuration;

import com.fasterxml.jackson.core.JsonParseException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;
import lombok.Data;

这些是已经在依赖里自动链接下载的对应包，在程序中需要用到对应的类

数据库的连接

官网的连接方法

private static final Logger logger = Logger.getLogger(BlogService.class.getCanonicalName());

    public static void main( String[] args) {
        CommandLineOptions options = new CommandLineOptions();
        //这里把连接数据库用到的信息集成到一个类中，可以方便下次调用使用，也是一种简化代码的方式
        new JCommander(options, args);//JCommander事JsonDe一个类，用来串联命令行和数据，可以在命令行中匹配登陆连接数据库
        //也只是猜测相应的功能

      //以下是为logger类加入信息
        logger.finest("Options.debug = " + options.debug);
        logger.finest("Options.database = " + options.database);
        logger.finest("Options.dbHost = " + options.dbHost);
        logger.finest("Options.dbUsername = " + options.dbUsername);
        logger.finest("Options.dbPort = " + options.dbPort);
        logger.finest("Options.servicePort = " + options.servicePort);

        port(options.servicePort);//链接接口，此处还是不是很理解

        Sql2o sql2o = new Sql2o("jdbc:mysql://" + options.dbHost + ":" + options.dbPort + "/" + options.database,
                options.dbUsername, options.dbPassword, new PostgresQuirks() {
            {
                // make sure we use default UUID converter.
                converters.put(UUID.class, new UUIDConverter());
            }
        });//连接数据库，并新建一个连接的对象，或者可以称之为接口

        Model model = new Sql2oModel(sql2o);//为Sql2oModel传入数据库接口

这是将登陆的信息集成到一个类中去掉用。通过sql2o，新建一个sql2o对象,然后传入主机名，主机的连接数据库的端口，数据库名，数据库的用户名，用户密码，以及 PostgreSQL 的对象-关系型数据库管理系统，来确保连接。

其实如果只是单纯的连接，不需要不需要系统的安全等要求可以直接输入这几个元素来直接连接，例如：

Sql2o sql2o =new Sql2o("jdbc:mysql://localhost:3306/blog","root","xz");//连接到我的mysql

建立一个对像Sql2oModel来对数据库进行操作

先建立具体的信息对象

public class Comment {
    String comment_uuid;
    String post_uuid;
    String author;
    String content;
    boolean approved;
    Date submission_date;
}

public class Post {
    private String post_uuid;
    private String title;
    private String content;
    private Date publishing_date;
    private List<String> categories;
    public String getPost_uuid(){return post_uuid;}
      public String getContent(){return content;}
      public String getTitle(){return title;}
      public void setCategories(List<String>cate){categories=cate;}
}

然后定义一个Sql2oModel的接口，具备改变数据库的完备功能

public interface Model {
    String createPost(String title, String content, List<String> categories);//创建Post对象并插入到数据中
    String createComment(String post, String author, String content);//创建Comment对象并与Post关联
    List<Post> getAllPosts();//获取所有的Posts对象，存在链表中
    List<Comment> getAllCommentsOn(String post);//获取所有的Comments对象，返回链表类
    boolean existPost(String post);//根据Posts来判断是否存在

    Optional<Post> getPost(String uuid);//根据uuid来判断对象是否存在

    void updatePost(Post post);//来更新信息

    void deletePost(String uuid);//删除掉Posts对象
}

接下来是Sql2oModel的实现

public class Sql2oModel implements Model{

  private Sql2o sql2o;//私有化
      private UuidGenerator uuidGenerator;
  public Sql2oModel(Sql2o sql2o) {//用sql2o做初始化，在Sql2oMdel的内部来执行对数据库的操作
        this.sql2o = sql2o;
        uuidGenerator= new RandomUuidGenerator(); //获取一个随机的uuid
    }
    @Override
    public String createPost(String title, String content, List<String> categories) {//创建一个post对象，插入到数据库中
        try (Connection conn = sql2o.beginTransaction()) {//开始对数据库的操作
            String postUuid = uuidGenerator.generate().toString();
            conn.createQuery("insert into posts(post_uuid, title, content, publishing_date) VALUES (:post_uuid, :title, :content, :date)")
                    .addParameter("post_uuid", postUuid)//由于mysql里面没有uuid类型，所以需要全部把，uuid类型转换为String类型在数据库中的表现为text类型
                    .addParameter("title", title)
                    .addParameter("content", content)
                    .addParameter("date", new Date())
                    .executeUpdate();//加入进去后更新数据
            categories.forEach((category) ->
                    conn.createQuery("insert into posts_categories(post_uuid, category) VALUES (:post_uuid, :category)")
                    .addParameter("post_uuid", postUuid)
                    .addParameter("category", category)
                    .executeUpdate());
            conn.commit();
            return postUuid;
        }
    }

    @Override
    public String createComment(String post, String author, String content) {
        try (Connection conn = sql2o.open()) {
            String commentUuid = uuidGenerator.generate().toString();
            conn.createQuery("insert into comments(comment_uuid, post_uuid, author, content, approved, submission_date) VALUES (:comment_uuid, :post_uuid, :author, :content, :approved, :date)")
                    .addParameter("comment_uuid", commentUuid.toString())
                    .addParameter("post_uuid", post)
                    .addParameter("author", author)
                    .addParameter("content", content)
                    .addParameter("approved", false)
                    .addParameter("date", new Date())
                    .executeUpdate();
            return commentUuid;
        }
    }

    @Override
    public List<Post> getAllPosts() { //获取所有的对象
        try (Connection conn = sql2o.open()) {
            List<Post> posts = conn.createQuery("select * from posts")
                    .executeAndFetch(Post.class);//执行指令
            posts.forEach((post) -> post.setCategories(getCategoriesFor(conn, post.getPost_uuid())));
            return posts;
        }
    }

    private List<String> getCategoriesFor(Connection conn, String post_uuid) {//来根据UUID来查找对象
        return conn.createQuery("select category from posts_categories where post_uuid=:post_uuid")
                .addParameter("post_uuid", post_uuid.toString())
                .executeAndFetch(String.class);
    }

    @Override
    public List<Comment> getAllCommentsOn(String post) {
        try (Connection conn = sql2o.open()) {
            return conn.createQuery("select * from comments where post_uuid=:post_uuid")
                    .addParameter("post_uuid", post.toString())
                    .executeAndFetch(Comment.class);
        }
    }

    @Override
    public boolean existPost(String post) {
        try (Connection conn = sql2o.open()) {
            List<Post> posts = conn.createQuery("select * from posts where post_uuid=:post")
                    .addParameter("post", post.toString())
                    .executeAndFetch(Post.class);
            return posts.size() > 0;
        }
    }
  @Override
    public Optional<Post> getPost(String uuid) {
        try (Connection conn = sql2o.open()) {
            List<Post> posts = conn.createQuery("select * from posts where post_uuid=:post_uuid")
                    .addParameter("post_uuid", uuid)
                    .executeAndFetch(Post.class);
            if (posts.size() == 0) {
                return Optional.empty();
            } else if (posts.size() == 1) {
                return Optional.of(posts.get(0));
            } else {
                throw new RuntimeException();
            }
        }
    }

    @Override
    public void updatePost(Post post) {
        try (Connection conn = sql2o.open()) {
            conn.createQuery("update posts set title=:title, content=:content where post_uuid=:post_uuid")
                    .addParameter("post_uuid", post.getPost_uuid())
                    .addParameter("title", post.getTitle())
                    .addParameter("content", post.getContent())
                    .executeUpdate();
        }
    }

    @Override
    public void deletePost(String uuid) {
        try (Connection conn = sql2o.open()) {
            conn.createQuery("delete from posts where post_uuid=:post_uuid")
                    .addParameter("post_uuid", uuid)
                    .executeUpdate();
        }
    }

}

这个是orm设计思想的体现，集成了所有对数据库的接口操作，用creatQuery（String ）来传入命令，更新数据，完成增删改查的操作。

接下来是在main函数中，建立路由的映射机制，可以通过访问网站来执行映射的相应操作

post("/posts", (request, response) -> {//创建相应的post对象
         ObjectMapper mapper = new ObjectMapper();  //用一个map的容器来实现映射
         NewPostPayload creation = mapper.readValue(request.body(), NewPostPayload.class);//把request的整体框架与一个Post
         if (!creation.isValid()) {//判断是否存在。
             response.status(HTTP_BAD_REQUEST);//如果错误就返回错误的状态值
             return "";
         }
         String id =new String( model.createPost(creation.getTitle(), creation.getContent(), creation.getCategories()));
        /*UUID id = UUID.fromString(model.createPost("creation.getTitle()", "creation.getContent()", new LinkedList<>()));*/
        StringWriter sw = new StringWriter();//此处不直接返回String类型，是我尝试直接返回是有错误的，所以直接参考了datetoJson的方法来返回，我觉得是数据需要封装后才能争取读到返回的信息。
        mapper.writeValue(sw, id);
         response.status(200);
         response.type("application/json");
         return sw.toString();//返回特定的uuid
     });

     // get all post (using HTTP get method)
     get("/posts", (request, response) -> {//获取所有post对象的信息
         response.status(200);
         response.type("application/json");
         return dataToJson(model.getAllPosts());
     });

     post("/posts/:uuid/comments", (request, response) -> {//创建一个comment对象并与相应的post联系
         ObjectMapper mapper = new ObjectMapper();
         NewCommentPayload creation = mapper.readValue(request.body(), NewCommentPayload.class);
         if (!creation.isValid()) {
             response.status(HTTP_BAD_REQUEST);
             return "";
         }
         if (!model.existPost(request.params(":uuid"))){
             response.status(400);
             return "";
         }
         UUID id = UUID.fromString(model.createComment(request.params(":uuid"), creation.getAuthor(), creation.getContent()));
         StringWriter sw = new StringWriter();
         mapper.writeValue(sw, id);
         response.status(200);
         response.type("application/json");
         return sw.toString();//返回uuid
     });

     get("/posts/:uuid/comments", (request, response) -> {//得到相应uuid的comment对象
         if (!model.existPost(request.params(":uuid"))) {
             response.status(400);
             return "";
         }
         response.status(200);
         response.type("application/json");
         return dataToJson(model.getAllCommentsOn(request.params(":uuid")));
     });
    }

测试

我用了官网推荐的postman工具来测试

创建一个post对象，并发送该包
这里写图片描述

这里写图片描述

如图返回的uuid为”6f92ac49-7194-4322-8a52-bc9076d62f49”

查询
这里写图片描述
可以查看到我们创建的对象

以uuid为指引建立comments对象

这里写图片描述

已创建

这里写图片描述

此处注意编辑包的时候要以特定格式，mysql才能识别得到信息，要不然就会报错

succ_mis
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
spring boot 启动 java.lang.ClassNotFoundException: com.sparkframework.sql.DB
角落的博客
07-10 1344
错误日志： DEBUG o.s.b.f.s.DefaultListableBeanFactory - Retrieved dependent beans for bean 'org.springframework.boot.autoconfigure.internalCachingMetadataReaderFactory': [org.springframework.context.annotation.internalConfigurationAnnotationProcessor] Excep
Spark-Framework:Spark精简web框架
07-02
Spark-Framework Spark精简web框架
Spark框架概述
藤藤菜的专栏
11-16 4656
定义：Apache Spark是用于处理的。弹性分布式数据集RDD是一种分布式内存抽象，其使得程序员能够在大规模集群中做内存运算，并且有一定的容错方式。而这也是整个Spark的核心数据结构，Spark整个平台都围绕着RDD进行。简而言之，Spark借鉴了MapReduce 思想发展而来，保留了其分布式并行计算的优点并改进了其明显的缺陷。让中间数据存储在内存中提高了运行速度、并提供丰富的操作数据的API提高了开发速度。统一分析引擎？Spark是一款分布式内存计算的统一分析引擎。
Spark框架概述、 Spark 框架模块详解、Spark 是什么、Spark 四大特点——速度快、易于使用、通用性强、运行方式多样
qq_40585384的博客
01-11 1万+
Spark 是加州大学伯克利分校AMP实验室（Algorithms Machines and People Lab）开发的通用大数据出来框架。Spark生态童也称为BDAS，是伯克利AMP实验室所开发的，力图在算法（Algorithms）、机器（Machines）和人（Person）三种之间通过大规模集成来展现大数据应用的一个开源平台。AMP实验室运用大数据、云计算等各种资源以及各种灵活的技术方案，对海量数据进行分析并转化为有用的信息，让人们更好地了解世界。
Maven构建Spark Framework Java项目--Linux命令行
CSerwangjun的博客
04-22 1608
一：所需软件        最新版的maven与java jdk，如何安装与配置环境变量请自行谷歌，有很多这方面的博客，不难。        给出一个安装教程链接http://www.linuxidc.com/Linux/2013-05/84489.htm 二：构建java项目 首先进入到你要构建项目的文件夹里 用mvn archetype:generate创建一个java项
spark读取hbase数据，并使用spark sql保存到mysql
09-24
使用spark读取hbase中的数据，并插入到mysql中
Spark与Mysql的交互
12-14
背景 　Spark在对目标数据进行... 　Error writing spark dataframe to mysql table JDBC batch insert performance 　还有些其他的贴 　- Using Apache Spark and MySQL for Data Analysis 　- spark 1.3.0 将d
spark连接mysql核心代码 java实现方式
06-22
spark连接mysql核心代码 java实现方式======================================================================
spring+mybatis+spark+mysql
09-07
自己研究学习大数据spark 整合 spring , mybati,maven写的例子，自己测试没有问题了，分享一下，有问题请拍砖。
Spark系列(一) —— SparkCore详解
吴明磊的博客
03-15 5950
1. =》Spark 引入 首先看一下MapReudce 计算和 Spark 计算的区别： MapReudce : 分布式计算框架 缺点：执行速度慢，shuffle 机制：数据需要输出到磁盘，而且每次 shuffle 都需要进行排序操作 框架的机制：只有 map 和 reduce 两个算子，对于比较复杂的任务，需要构建多个job来执行，当存在 job 依赖的时候，job 之间的数据...
spark写入mysql的几种方法，针对不同场景
心雨先生
09-27 2194
方法一：各个字段都是提前定好的 val prop = new java.util.Properties prop.setProperty("user", "root") prop.setProperty("password", "123456") df1.write.mode(SaveMode.Append).jdbc("jdbc:mysql://192.168.1.97:3306/xian...
spark sql demo
liben2007的博客
03-02 649
通过pojo构造table： package sparkSql; import org.apache.spark.SparkConf; import org.apache.spark.api.java.JavaRDD; import org.apache.spark.api.java.JavaSparkContext; import org.apache.spark.api.java.func
SparkSql将数据写入到MySQL
Running_Tiger的博客
03-11 1万+
SparkSql将数据写入到MySQL1、通过IDEA编写SparkSql代码package cn.cheng.sql import java.util.Properties import org.apache.spark.rdd.RDD import org.apache.spark.sql.{DataFrame, Dataset, SaveMode, SparkSession} /** *
SecurityUtil
涂作权的博客
05-03 1万+
package com.css.common.util; import java.security.MessageDigest; /**  * 公共方法类  * md5算法实现  *  * @version 1.0  *  */ public class SecurityUtil  {   /**    * md5加密算法    * @param value 欲使用md5
spark读取MySQL大Table的效能问题
sun
07-05 7069
在测试从Spark Shell读取MySQL一张Large Table时，发生了Out of memory和connection timeout问题，记录一下处理的过程： MySQL Table资料笔数：1400万笔左右 Spark Cluster配置：Master * 1，Slave * 3，皆为1 core 8G  Spark版本：2.1.1 星火配置配置： spark-en
Spark2.1.0之内置RPC框架
beliefer的博客
06-27 9335
        在Spark中很多地方都涉及网络通信，比如Spark各个组件间的消息互通、用户文件与Jar包的上传、节点间的Shuffle过程、Block数据的复制与备份等。在Spark 0.x.x与Spark 1.x.x版本中，组件间的消息通信主要借助于Akka[1]，使用Akka可以轻松的构建强有力的高并发与分布式应用。但是Akka在Spark 2.0.0版本中被移除了，Spark官网文档对此...
spark写入mysql的几种方法
热门推荐
驰骋天下
02-11 1万+
方法一：各个字段都是提前定好的 val prop = new java.util.Properties prop.setProperty(&amp;quot;user&amp;quot;, &amp;quot;root&amp;quot;) prop.setProperty(&amp;quot;password&amp;quot;, &amp;quot;123456&amp;quot;) df1.write.mode(SaveMod
spark hive写mysql
最新发布
04-30
下面我将介绍如何使用Spark和Hive来将数据写入MySQL数据库。 首先，需要在Spark中定义一个DataFrame，它包含了需要写入MySQL的数据。然后，使用Spark提供的JDBC接口将DataFrame中的数据写入到MySQL中。以下是示例...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值