需要实现的功能：

写访问spark的接口，也就是从web上输入网址就能把我们需要的信息通过提交一个job然后返回给我们json数据。

成果展示：

通过url请求，然后的到一个wordcount的json结果（借助的是谷歌浏览器postman插件显示的，直接在浏览器上输入网址是一样的效果）

使用的关键技术：

java语言编程，springmvc框架，tomcat容器，spark框架，scala相关依赖

成体架构：

我使用的是maven构建的一个web工程，pom文件如下：

  1.  <dependencies>
  2.     <!-- https://mvnrepository.com/artifact/junit/junit -->
  3.         <dependency>
  4.             <groupId>junit</groupId>
  5.             <artifactId>junit</artifactId>
  6.             <version>4.12</version>
  7.             <scope>test</scope>
  8.         </dependency>
  9.         <!-- https://mvnrepository.com/artifact/org.apache.spark/spark-core_2.11 -->
  10.         <dependency>
  11.             <groupId>org.apache.spark</groupId>
  12.             <artifactId>spark-core_2.</artifactId>
  13.             <version>1.6.</version>
  14.  
  15.         </dependency>
  16.         <!-- https://mvnrepository.com/artifact/org.apache.spark/spark-sql_2.11 -->
  17.         <dependency>
  18.             <groupId>org.apache.spark</groupId>
  19.             <artifactId>spark-sql_2.</artifactId>
  20.             <version>1.6.</version>
  21.  
  22.         </dependency>
  23.         <!-- https://mvnrepository.com/artifact/org.scala-lang/scala-library -->
  24.         <dependency>
  25.             <groupId>org.scala-lang</groupId>
  26.             <artifactId>scala-library</artifactId>
  27.             <version>2.11.</version>
  28.         </dependency>
  29.         <!-- https://mvnrepository.com/artifact/org.scala-lang/scala-reflect -->
  30.         <dependency>
  31.             <groupId>org.scala-lang</groupId>
  32.             <artifactId>scala-reflect</artifactId>
  33.             <version>2.11.</version>
  34.         </dependency>
  35.         <!-- https://mvnrepository.com/artifact/org.scala-lang/scala-compiler -->
  36.         <dependency>
  37.             <groupId>org.scala-lang</groupId>
  38.             <artifactId>scala-compiler</artifactId>
  39.             <version>2.11.</version>
  40.         </dependency>
  41.  
  42.         <!-- spring框架的相关jar包 -->
  43.         <dependency>
  44.           <groupId>org.springframework</groupId>
  45.           <artifactId>spring-context</artifactId>
  46.           <version>4.3..RELEASE</version>
  47.         </dependency>
  48.         <!-- https://mvnrepository.com/artifact/org.springframework/spring-jdbc -->
  49.         <dependency>
  50.           <groupId>org.springframework</groupId>
  51.           <artifactId>spring-jdbc</artifactId>
  52.           <version>4.3..RELEASE</version>
  53.         </dependency>
  54.         <!-- https://mvnrepository.com/artifact/org.springframework/spring-web -->
  55.         <dependency>
  56.           <groupId>org.springframework</groupId>
  57.           <artifactId>spring-web</artifactId>
  58.           <version>4.3..RELEASE</version>
  59.         </dependency>
  60.         <!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
  61.         <dependency>
  62.           <groupId>org.springframework</groupId>
  63.           <artifactId>spring-webmvc</artifactId>
  64.           <version>4.3..RELEASE</version>
  65.         </dependency>
  66.  
  67.         <!--添加持久层框架（mybatise）-->
  68.         <!-- https://mvnrepository.com/artifact/org.mybatis/mybatis -->
  69.         <dependency>
  70.           <groupId>org.mybatis</groupId>
  71.           <artifactId>mybatis</artifactId>
  72.           <version>3.4.</version>
  73.         </dependency>
  74.  
  75.         <!--mybatise和spring整合包-->
  76.         <!-- https://mvnrepository.com/artifact/org.mybatis/mybatis-spring -->
  77.         <dependency>
  78.           <groupId>org.mybatis</groupId>
  79.           <artifactId>mybatis-spring</artifactId>
  80.           <version>1.3.</version>
  81.         </dependency>
  82.         <!--  -->
  83.         <dependency>
  84.           <groupId>commons-DBCP</groupId>
  85.           <artifactId>commons-DBCP</artifactId>
  86.           <version>1.4</version>
  87.         </dependency>
  88.         <dependency>
  89.           <groupId>org.aspectj</groupId>
  90.           <artifactId>aspectjweaver</artifactId>
  91.           <version>1.8.</version>
  92.         </dependency>
  93.  
  94.         <!--添加连接池的jar包-->
  95.         <!-- https://mvnrepository.com/artifact/com.alibaba/druid -->
  96.         <dependency>
  97.           <groupId>com.alibaba</groupId>
  98.           <artifactId>druid</artifactId>
  99.           <version>1.0.</version>
  100.         </dependency>
  101.         <!--添加数据库驱动-->
  102.         <!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
  103.         <dependency>
  104.           <groupId>mysql</groupId>
  105.           <artifactId>mysql-connector-java</artifactId>
  106.           <version>5.1.</version>
  107.         </dependency>
  108.         <!-- 日志处理 -->
  109.         <!-- https://mvnrepository.com/artifact/org.slf4j/slf4j-api -->
  110.         <dependency>
  111.             <groupId>org.slf4j</groupId>
  112.             <artifactId>slf4j-api</artifactId>
  113.             <version>1.7.</version>
  114.         </dependency>
  115.         <!-- https://mvnrepository.com/artifact/org.slf4j/slf4j-log4j12 -->
  116.         <dependency>
  117.             <groupId>org.slf4j</groupId>
  118.             <artifactId>slf4j-log4j12</artifactId>
  119.             <version>1.7.</version>
  120.         </dependency>
  121.         <!-- https://mvnrepository.com/artifact/log4j/log4j -->
  122.         <dependency>
  123.             <groupId>log4j</groupId>
  124.             <artifactId>log4j</artifactId>
  125.             <version>1.2.</version>
  126.         </dependency>
  127.         <!--json相关的依赖，不要使用jackson的依赖-->
  128.         <dependency>
  129.             <groupId>net.sf.json-lib</groupId>
  130.             <artifactId>json-lib</artifactId>
  131.             <version>2.4</version>
  132.             <classifier>jdk15</classifier>
  133.         </dependency>
  134.   </dependencies>

web.xml的配置（这里只配置了springmvc容器）

  1. <?xml version="1.0" encoding="UTF-8"?>
  2.  
  3. <web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd" id="WebApp_ID" version="3.0">
  4.  
  5.   <display-name>Archetype Created Web Application</display-name>
  6.   <!-- springmvc的前端控制器 -->
  7.   <servlet>
  8.     <servlet-name>manager</servlet-name>
  9.     <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
  10.     <!-- contextConfigLocation不是必须的， 如果不配置contextConfigLocation， springmvc的配置文件默认在：WEB-INF/servlet的name+"-servlet.xml" -->
  11.     <init-param>
  12.       <param-name>contextConfigLocation</param-name>
  13.       <param-value>classpath:springmvc.xml</param-value>
  14.     </init-param>
  15.     <load-on-startup></load-on-startup>
  16.   </servlet>
  17.   <servlet-mapping>
  18.     <servlet-name>manager</servlet-name>
  19.     <url-pattern>/</url-pattern>
  20.   </servlet-mapping>
  21.  
  22.   <!-- 解决post乱码 -->
  23.   <filter>
  24.     <filter-name>CharacterEncodingFilter</filter-name>
  25.     <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
  26.     <init-param>
  27.       <param-name>encoding</param-name>
  28.       <param-value>utf-</param-value>
  29.     </init-param>
  30.   </filter>
  31.   <filter-mapping>
  32.     <filter-name>CharacterEncodingFilter</filter-name>
  33.     <url-pattern>/*</url-pattern>
  34.   </filter-mapping>
  35.  
  36.   <!-- 日志配置 -->
  37.   <context-param>
  38.     <param-name>log4jConfigLocation</param-name>
  39.     <param-value>classpath:log4j.properties</param-value>
  40.   </context-param>
  41.   <listener>
  42.     <listener-class>org.springframework.web.util.Log4jConfigListener</listener-class>
  43.   </listener>
  44. </web-app>

然后就是springMVC的配置文件

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"
  4.     xmlns:context="http://www.springframework.org/schema/context"
  5.     xmlns:mvc="http://www.springframework.org/schema/mvc"
  6.     xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.3.xsd
  7.         http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-4.0.xsd
  8.         http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
  9.     <!-- 配置包扫描器 -->
  10.     <context:component-scan base-package="com.zzrenfeng.zhsx.controller" />
  11.       <!-- 配置注解驱动 -->
  12.     <mvc:annotation-driven />
  13.  
  14.     <context:component-scan base-package="com.zzrenfeng.zhsx.service"></context:component-scan>
  15.     <context:component-scan base-package="com.zzrenfeng.zhsx.spark.service"></context:component-scan>
  16.     <context:component-scan base-package="com.zzrenfeng.zhsx.spark.conf"></context:component-scan>
  17. </beans>

配置文件就就没有了，如果有需要可以再去集成其他的，下面进入编码的介绍

对象和json相互转换的工具类：

（为什么使用手动的去转换，而没有使用jackson的相关依赖进行自动转换，是我在使用的时候发现使用jackson会对咱们的spark作业有影响，spark作业会异常终止掉）

  1. package com.zzrenfeng.zhsx.util;
  2. import java.lang.reflect.Field;
  3. import java.util.ArrayList;
  4. import java.util.HashMap;
  5. import java.util.Iterator;
  6. import java.util.List;
  7. import java.util.Map;
  8. import java.util.Set;  
  9.  
  10. import net.sf.json.JSONArray;
  11. import net.sf.json.JSONObject;
  12. import net.sf.json.JsonConfig;  
  13.  
  14. /**
  15.  * Json与javaBean之间的转换工具类
  16.  *
  17.  * @author
  18.  * @version
  19.  *
  20.  * {@code   现使用json-lib组件实现
  21.  *          需要
  22.  *              json-lib-2.4-jdk15.jar
  23.  *              ezmorph-1.0.6.jar
  24.  *              commons-collections-3.1.jar
  25.  *              commons-lang-2.0.jar
  26.  *          支持
  27.  * }
  28.  */
  29. public class JsonUtil {  
  30.  
  31.     /**
  32.      * 从一个JSON 对象字符格式中得到一个java对象
  33.      *
  34.      * @param jsonString
  35.      * @param beanCalss
  36.      * @return
  37.      */
  38.     @SuppressWarnings("unchecked")
  39.     public static <T> T jsonToBean(String jsonString, Class<T> beanCalss) {  
  40.  
  41.         JSONObject jsonObject = JSONObject.fromObject(jsonString);
  42.         T bean = (T) JSONObject.toBean(jsonObject, beanCalss);  
  43.  
  44.         return bean;  
  45.  
  46.     }  
  47.  
  48.     /**
  49.      * 将java对象转换成json字符串
  50.      *
  51.      * @param bean
  52.      * @return
  53.      */
  54.     public static String beanToJson(Object bean) {  
  55.  
  56.         JSONObject json = JSONObject.fromObject(bean);  
  57.  
  58.         return json.toString();  
  59.  
  60.     }  
  61.  
  62.     /**
  63.      * 将java对象转换成json字符串
  64.      *
  65.      * @param bean
  66.      * @return
  67.      */
  68.     public static String beanToJson(Object bean, String[] _nory_changes, boolean nory) {  
  69.  
  70.         JSONObject json = null;  
  71.  
  72.         if(nory){//转换_nory_changes里的属性  
  73.  
  74.             Field[] fields = bean.getClass().getDeclaredFields();
  75.             String str = "";
  76.             for(Field field : fields){
  77. //              System.out.println(field.getName());
  78.                 str+=(":"+field.getName());
  79.             }
  80.             fields = bean.getClass().getSuperclass().getDeclaredFields();
  81.             for(Field field : fields){
  82. //              System.out.println(field.getName());
  83.                 str+=(":"+field.getName());
  84.             }
  85.             str+=":";
  86.             for(String s : _nory_changes){
  87.                 str = str.replace(":"+s+":", ":");
  88.             }
  89.             json = JSONObject.fromObject(bean,configJson(str.split(":")));  
  90.  
  91.         }else{//转换除了_nory_changes里的属性  
  92.  
  93.             json = JSONObject.fromObject(bean,configJson(_nory_changes));
  94.         }  
  95.  
  96.         return json.toString();  
  97.  
  98.     }
  99.      private static JsonConfig configJson(String[] excludes) {     
  100.  
  101.                 JsonConfig jsonConfig = new JsonConfig();     
  102.  
  103.                 jsonConfig.setExcludes(excludes);
  104. //
  105.                 jsonConfig.setIgnoreDefaultExcludes(false);
  106. //
  107. //              jsonConfig.setCycleDetectionStrategy(CycleDetectionStrategy.LENIENT);     
  108.  
  109. //              jsonConfig.registerJsonValueProcessor(Date.class,
  110. //
  111. //                  new DateJsonValueProcessor(datePattern));     
  112.  
  113.                 return jsonConfig;     
  114.  
  115.             }    
  116.  
  117.     /**
  118.      * 将java对象List集合转换成json字符串
  119.      * @param beans
  120.      * @return
  121.      */
  122.     @SuppressWarnings("unchecked")
  123.     public static String beanListToJson(List beans) {  
  124.  
  125.         StringBuffer rest = new StringBuffer();  
  126.  
  127.         rest.append("[");  
  128.  
  129.         int size = beans.size();  
  130.  
  131.         for (int i = ; i < size; i++) {  
  132.  
  133.             rest.append(beanToJson(beans.get(i))+((i<size-)?",":""));  
  134.  
  135.         }  
  136.  
  137.         rest.append("]");  
  138.  
  139.         return rest.toString();  
  140.  
  141.     }  
  142.  
  143.     /**
  144.      *
  145.      * @param beans
  146.      * @param _no_changes
  147.      * @return
  148.      */
  149.     @SuppressWarnings("unchecked")
  150.     public static String beanListToJson(List beans, String[] _nory_changes, boolean nory) {  
  151.  
  152.         StringBuffer rest = new StringBuffer();  
  153.  
  154.         rest.append("[");  
  155.  
  156.         int size = beans.size();  
  157.  
  158.         for (int i = ; i < size; i++) {
  159.             try{
  160.                 rest.append(beanToJson(beans.get(i),_nory_changes,nory));
  161.                 if(i<size-){
  162.                     rest.append(",");
  163.                 }
  164.             }catch(Exception e){
  165.                 e.printStackTrace();
  166.             }
  167.         }  
  168.  
  169.         rest.append("]");  
  170.  
  171.         return rest.toString();  
  172.  
  173.     }  
  174.  
  175.     /**
  176.      * 从json HASH表达式中获取一个map，改map支持嵌套功能
  177.      *
  178.      * @param jsonString
  179.      * @return
  180.      */
  181.     @SuppressWarnings({ "unchecked" })
  182.     public static Map jsonToMap(String jsonString) {  
  183.  
  184.         JSONObject jsonObject = JSONObject.fromObject(jsonString);
  185.         Iterator keyIter = jsonObject.keys();
  186.         String key;
  187.         Object value;
  188.         Map valueMap = new HashMap();  
  189.  
  190.         while (keyIter.hasNext()) {  
  191.  
  192.             key = (String) keyIter.next();
  193.             value = jsonObject.get(key).toString();
  194.             valueMap.put(key, value);  
  195.  
  196.         }  
  197.  
  198.         return valueMap;
  199.     }  
  200.  
  201.     /**
  202.      * map集合转换成json格式数据
  203.      * @param map
  204.      * @return
  205.      */
  206.     public static String mapToJson(Map<String, ?> map, String[] _nory_changes, boolean nory){  
  207.  
  208.         String s_json = "{";  
  209.  
  210.          Set<String> key = map.keySet();
  211.          for (Iterator<?> it = key.iterator(); it.hasNext();) {
  212.              String s = (String) it.next();
  213.              if(map.get(s) == null){  
  214.  
  215.              }else if(map.get(s) instanceof List<?>){
  216.                  s_json+=(s+":"+JsonUtil.beanListToJson((List<?>)map.get(s), _nory_changes, nory));  
  217.  
  218.              }else{
  219.                  JSONObject json = JSONObject.fromObject(map);
  220.                  s_json += (s+":"+json.toString());;
  221.              }  
  222.  
  223.              if(it.hasNext()){
  224.                  s_json+=",";
  225.              }
  226.         }  
  227.  
  228.          s_json+="}";
  229.         return s_json;
  230.     }  
  231.  
  232.     /**
  233.      * 从json数组中得到相应java数组
  234.      *
  235.      * @param jsonString
  236.      * @return
  237.      */
  238.     public static Object[] jsonToObjectArray(String jsonString) {  
  239.  
  240.         JSONArray jsonArray = JSONArray.fromObject(jsonString);  
  241.  
  242.         return jsonArray.toArray();  
  243.  
  244.     }  
  245.  
  246.     public static String listToJson(List<?> list) {  
  247.  
  248.         JSONArray jsonArray = JSONArray.fromObject(list);  
  249.  
  250.         return jsonArray.toString();  
  251.  
  252.     }  
  253.  
  254.     /**
  255.      * 从json对象集合表达式中得到一个java对象列表
  256.      *
  257.      * @param jsonString
  258.      * @param beanClass
  259.      * @return
  260.      */
  261.     @SuppressWarnings("unchecked")
  262.     public static <T> List<T> jsonToBeanList(String jsonString, Class<T> beanClass) {  
  263.  
  264.         JSONArray jsonArray = JSONArray.fromObject(jsonString);
  265.         JSONObject jsonObject;
  266.         T bean;
  267.         int size = jsonArray.size();
  268.         List<T> list = new ArrayList<T>(size);  
  269.  
  270.         for (int i = ; i < size; i++) {  
  271.  
  272.             jsonObject = jsonArray.getJSONObject(i);
  273.             bean = (T) JSONObject.toBean(jsonObject, beanClass);
  274.             list.add(bean);  
  275.  
  276.         }  
  277.  
  278.         return list;  
  279.  
  280.     }  
  281.  
  282.     /**
  283.      * 从json数组中解析出java字符串数组
  284.      *
  285.      * @param jsonString
  286.      * @return
  287.      */
  288.     public static String[] jsonToStringArray(String jsonString) {  
  289.  
  290.         JSONArray jsonArray = JSONArray.fromObject(jsonString);
  291.         String[] stringArray = new String[jsonArray.size()];
  292.         int size = jsonArray.size();  
  293.  
  294.         for (int i = ; i < size; i++) {  
  295.  
  296.             stringArray[i] = jsonArray.getString(i);  
  297.  
  298.         }  
  299.  
  300.         return stringArray;
  301.     }  
  302.  
  303.     /**
  304.      * 从json数组中解析出javaLong型对象数组
  305.      *
  306.      * @param jsonString
  307.      * @return
  308.      */
  309.     public static Long[] jsonToLongArray(String jsonString) {  
  310.  
  311.         JSONArray jsonArray = JSONArray.fromObject(jsonString);
  312.         int size = jsonArray.size();
  313.         Long[] longArray = new Long[size];  
  314.  
  315.         for (int i = ; i < size; i++) {  
  316.  
  317.             longArray[i] = jsonArray.getLong(i);  
  318.  
  319.         }  
  320.  
  321.         return longArray;  
  322.  
  323.     }  
  324.  
  325.     /**
  326.      * 从json数组中解析出java Integer型对象数组
  327.      *
  328.      * @param jsonString
  329.      * @return
  330.      */
  331.     public static Integer[] jsonToIntegerArray(String jsonString) {  
  332.  
  333.         JSONArray jsonArray = JSONArray.fromObject(jsonString);
  334.         int size = jsonArray.size();
  335.         Integer[] integerArray = new Integer[size];  
  336.  
  337.         for (int i = ; i < size; i++) {  
  338.  
  339.             integerArray[i] = jsonArray.getInt(i);  
  340.  
  341.         }  
  342.  
  343.         return integerArray;  
  344.  
  345.     }  
  346.  
  347.     /**
  348.      * 从json数组中解析出java Double型对象数组
  349.      *
  350.      * @param jsonString
  351.      * @return
  352.      */
  353.     public static Double[] jsonToDoubleArray(String jsonString) {  
  354.  
  355.         JSONArray jsonArray = JSONArray.fromObject(jsonString);
  356.         int size = jsonArray.size();
  357.         Double[] doubleArray = new Double[size];  
  358.  
  359.         for (int i = ; i < size; i++) {  
  360.  
  361.             doubleArray[i] = jsonArray.getDouble(i);  
  362.  
  363.         }  
  364.  
  365.         return doubleArray;  
  366.  
  367.     }  
  368.  
  369. } 
  1. spark的工具类：（主要负责sparkcontext的初始化工作）
  1. package com.zzrenfeng.zhsx.spark.conf;
  2.  
  3. import java.io.Serializable;
  4.  
  5. import org.apache.spark.SparkConf;
  6. import org.apache.spark.api.java.JavaSparkContext;
  7. import org.springframework.context.support.PropertySourcesPlaceholderConfigurer;
  8. import org.springframework.stereotype.Component;
  9.  
  10. @Component
  11. public class ApplicationConfiguration implements Serializable{
  12.  
  13.     private static final long serialVersionUID = 1L;
  14.  
  15.     public SparkConf sparkconf(){
  16.         SparkConf conf = new SparkConf()
  17.             .setMaster("local[*]")
  18.             .setAppName("wc");
  19.         return conf;
  20.     }
  21.     public JavaSparkContext javaSparkContext(){
  22.  
  23.         return new JavaSparkContext(sparkconf());
  24.     }
  25.  
  26.     public static PropertySourcesPlaceholderConfigurer propertySourcesPlaceholderConfigurer() {
  27.         return new PropertySourcesPlaceholderConfigurer();
  28.     }
  29.  
  30.     public String filePath(){
  31.         return "E:\\测试文件\\nlog.txt";
  32.     }
  33. }

wordcount model类（对wordcount进行封装）

  1. package com.zzrenfeng.zhsx.spark.domain;
  2.  
  3. import scala.Serializable;
  4.  
  5. public class WordCount implements Serializable{
  6.     /**
  7.      *
  8.      */
  9.     private static final long serialVersionUID = 1L;
  10.     private String word;
  11.     private Integer count;
  12.     public WordCount(){}
  13.     public WordCount(String v1, int l) {
  14.         word = v1;
  15.         count = l;
  16.     }
  17.     public String getWord() {
  18.         return word;
  19.     }
  20.     public void setWord(String word) {
  21.         this.word = word;
  22.     }
  23.     public int getCount() {
  24.         return count;
  25.     }
  26.     public void setCount(int count) {
  27.         this.count = count;
  28.     }
  29.     @Override
  30.     public String toString() {
  31.         return "WordCount [word=" + word + ", count=" + count + "]";
  32.     }
  33.  
  34. }

spark service类，主要是负责spark word count的job任务逻辑

  1. package com.zzrenfeng.zhsx.spark.service;
  2.  
  3. import java.util.Arrays;
  4. import java.util.List;
  5.  
  6. import org.apache.spark.api.java.JavaPairRDD;
  7. import org.apache.spark.api.java.JavaRDD;
  8. import org.apache.spark.api.java.JavaSparkContext;
  9. import org.apache.spark.api.java.function.FlatMapFunction;
  10. import org.apache.spark.api.java.function.Function;
  11. import org.apache.spark.api.java.function.Function2;
  12. import org.apache.spark.api.java.function.PairFunction;
  13. import org.springframework.beans.factory.annotation.Autowired;
  14. import org.springframework.stereotype.Component;
  15.  
  16. import scala.Tuple2;
  17.  
  18. import com.zzrenfeng.zhsx.spark.conf.ApplicationConfiguration;
  19. import com.zzrenfeng.zhsx.spark.domain.WordCount;
  20. @Component
  21. public class SparkServiceTest implements java.io.Serializable{
  22.     @Autowired
  23.     ApplicationConfiguration applicationConfiguration;
  24.  
  25.     public List<WordCount> doWordCount(){
  26.         JavaSparkContext javaSparkContext = applicationConfiguration.javaSparkContext();
  27.         System.out.println(javaSparkContext);
  28.         JavaRDD<String> file = javaSparkContext.textFile(applicationConfiguration.filePath());
  29.         JavaRDD<String> worlds = file.flatMap(new FlatMapFunction<String, String>() {
  30.  
  31.             @Override
  32.             public Iterable<String> call(String t) throws Exception {
  33.                 // TODO Auto-generated method stub
  34.                 List<String> list = Arrays.asList(t.split(" "));
  35.                 return list;
  36.             }
  37.         });
  38.         JavaRDD<WordCount> wordcount = worlds.map(new Function<String, WordCount>() {
  39.  
  40.             @Override
  41.             public WordCount call(String v1) throws Exception {
  42.  
  43.                 return new WordCount(v1,);
  44.             }
  45.         });
  46.         JavaPairRDD<String, Integer> pairwordCount = wordcount.mapToPair(new PairFunction<WordCount, String, Integer>() {
  47.  
  48.             @Override
  49.             public Tuple2<String, Integer> call(WordCount t) throws Exception {
  50.                 // TODO Auto-generated method stub
  51.                 return new Tuple2<>(t.getWord() , new Integer(t.getCount()));
  52.  
  53.             }
  54.         });
  55.  
  56.         JavaPairRDD<String, Integer> worldCounts = pairwordCount.reduceByKey(new Function2<Integer, Integer, Integer>() {
  57.  
  58.             @Override
  59.             public Integer call(Integer v1, Integer v2) throws Exception {
  60.                 // TODO Auto-generated method stub
  61.                 return v1+v2;
  62.             }
  63.         });
  64.         JavaRDD result = worldCounts.map(new Function<Tuple2<String,Integer>, WordCount>() {
  65.  
  66.             @Override
  67.             public WordCount call(Tuple2<String, Integer> v1) throws Exception {
  68.                 // TODO Auto-generated method stub
  69.                 return new WordCount(v1._1,v1._2);
  70.             }
  71.         });
  72.         List<WordCount> list = result.collect();
  73.         javaSparkContext.close();
  74.         System.out.println(list.toString());
  75.         return list;
  76.     }
  77.  
  78. }

controller层，主要负责请求的拦截

  1. package com.zzrenfeng.zhsx.controller;
  2.  
  3. import java.util.ArrayList;
  4. import java.util.List;
  5.  
  6. import org.springframework.beans.factory.annotation.Autowired;
  7. import org.springframework.stereotype.Controller;
  8. import org.springframework.ui.Model;
  9. import org.springframework.web.bind.annotation.RequestMapping;
  10. import org.springframework.web.bind.annotation.RequestMethod;
  11. import org.springframework.web.bind.annotation.ResponseBody;
  12.  
  13. import com.zzrenfeng.zhsx.spark.domain.WordCount;
  14. import com.zzrenfeng.zhsx.spark.service.SparkServiceTest;
  15. import com.zzrenfeng.zhsx.util.JsonUtil;
  16.  
  17. @Controller
  18. @RequestMapping("hello")
  19. public class ControllerTest {
  20.     @Autowired
  21.     private SparkServiceTest sparkServiceTest;
  22.  
  23.     @RequestMapping("wc")
  24.     @ResponseBody
  25.     public String wordCount(){
  26.         List<WordCount> list = sparkServiceTest.doWordCount();
  27.         return JsonUtil.listToJson(list);
  28.     }
  29. }

进行启动，然后在浏览器上输入上面的拦截的url就可以看到开始出现的结果了。 
因为这是个web接口，所以可以从各个端去调用，甚至可以用其他语言去调用。 
现在可以愉快的去撸spark代码了，也许有人会问spark不应该用scala开发更好吗？ 
个人认为如果是纯粹的数据处理可以使用scala，编写起来太爽了，但是跟其他的集成的时候最好还是用java，毕竟有问题了还可以跟java大牛去讨论讨论。 
欢迎有兴趣的一起来探讨

Spark与Spring集成做web接口的更多相关文章

  1. 使用Apache CXF和Spring集成创建Web Service（zz）

    使用Apache CXF和Spring集成创建Web Service 您的评价:       还行  收藏该经验       1.创建HelloWorld 接口类 查看源码 打印? 1 package ...

  2. SSM框架开发web项目系列（五） Spring集成MyBatis

    前言 在前面的MyBatis部分内容中,我们已经可以独立的基于MyBatis构建一个数据库访问层应用,但是在实际的项目开发中,我们的程序不会这么简单,层次也更加复杂,除了这里说到的持久层,还有业务逻辑 ...

  3. Spring集成shiro做登陆认证

    一.背景 其实很早的时候,就在项目中有使用到shiro做登陆认证,直到今天才又想起来这茬,自己抽空搭了一个spring+springmvc+mybatis和shiro进行集成的种子项目,当然里面还有很 ...

  4. Mybatis与Spring集成时都做了什么？

    Mybatis是java开发者非常熟悉的ORM框架,Spring集成Mybatis更是我们的日常开发姿势. 本篇主要讲Mybatis与Spring集成所做的事情,让读过本文的开发者对Mybatis和S ...

  5. Spring 4 官方文档学习（十三）集成其他web框架

    重点是通用配置,非常建议看一下!有助于理解Spring的ApplicationContext与Servlet Container的关系! 1.介绍 Spring Web Flow SWF目标是成为we ...

  6. Spring集成web环境（使用封装好的工具）

    接上文spring集成web环境(手动实现) ##########代码接上文############# spring提供了一个监听器ContextLoaderListener对上述功能的封装,该监听器 ...

  7. 使用shell做http web接口，可以传递参数--废弃

    此文章废弃,参考另一篇 参考网址: https://me.jinchuang.org/archives/114.html https://www.cnblogs.com/jinchuang/p/142 ...

  8. spring集成常用技术的配置

    使用spring集成其他技术,最基本的配置都是模板化的,比如配置视图模板引擎.数据库连接池.orm框架.缓存服务.邮件服务.rpc调用等,以spring的xml配置为例,我将这些配置过程整理出来,并不 ...

  9. 使用 Spring Security 保护 Web 应用的安全

    安全一直是 Web 应用开发中非常重要的一个方面.从安全的角度来说,需要考虑用户认证和授权两个方面.为 Web 应用增加安全方面的能力并非一件简单的事情,需要考虑不同的认证和授权机制.Spring S ...

随机推荐

  1. Android设计和开发系列第二篇：Navigation Drawer(Develop)

    Creating a Navigation Drawer THIS LESSON TEACHES YOU TO: Create a Drawer Layout Initialize the Drawe ...

  2. 文件系统的挂载(2)---挂载rootfs文件系统

    一.目的 本文主要讲述linux内核rootfs文件系统的挂载过程,内核版本为3.10. rootfs是基于内存的文件系统,没有实际的存储设备,所有操作都在内存中完成.为了保证linux内核的精简性, ...

  3. php-config

    php-config php-config 是一个简单的命令行脚本用于获取所安装的 PHP 配置的信息. 在编译扩展时,如果安装有多个 PHP 版本,可以在配置时用 --with-php-config ...

  4. MySQL大数据量分页性能优化

    mysql大数据量使用limit分页,随着页码的增大,查询效率越低下. 测试实验 1.   直接用limit start, count分页语句, 也是我程序中用的方法: select * from p ...

  5. linux下php redis扩展安装

    sudo tar vxzf redis-2.2.7.tgz cd redis-2.2.7 执行sudo /data/service/php54/bin/phpize 在目录下生成配置文件 sudo . ...

  6. PostgreSQL索引介绍

    h1, h2, h3, h4, h5, h6, p, blockquote { margin: 5px; padding: 5; } body { font-family: "Helveti ...

  7. 【JSP】JSP的介绍和基本原理

    JSP简介 JSP的核心实质是Servlet技术.JSP是后来添加的基于Servlet的一种扩展技术.但二者在使用上有不同的方向. 由于Servlet实质是一个Java类,因此非常适合用来处理业务逻辑 ...

  8. 预编译 ASP.NET 网站以进行部署

    预编译 ASP.NET 网站以进行部署和更新 打开一个命令窗口并定位到包含 .NET Framework 的文件夹. .NET Framework 将安装在以下位置. %windir%\Microso ...

  9. Unity3D笔记 英保通九 创建数

    Unity中创建树:可以直接通过程序自动来创建树木还可以手动创建树木(本质上在我看来就是给程序自动创建的树动动”小手术“) 一.程序自动创建树木 3.1.层次视图中创建:一个平行光.摄像机.地.数并且 ...

  10. 使用disavled属性锁定input内容不可以修改后，打印获取不到对应的值

    当我们需要锁定input内容不让修改时,可以使用disabled="disabled"和readonly="readonly", 官方的解释是:disabled ...