使用maven创建基于spring框架的scala web工程

最新推荐文章于 2024-03-07 18:33:16 发布
最新推荐文章于 2024-03-07 18:33:16 发布
阅读量2.1k 收藏 4
点赞数
分类专栏： Scala 文章标签： spring scala web java 
最近在研究如何使用scala进行web开发的过程中，发现资料都很少。参考很多文章的例子，工程都运行不起来。所以，写下这篇文章。
lift是基于scala语言开发的web框架。但考虑到目前java程序员对spring框架比较熟悉。因此选择spring框架作为scala web工程的框架。
使用maven作为项目管理工具。

1 使用maven创建工程

mvn archetype:generate -U -DarchetypeGroupId=org.scala-tools.archetypes -DarchetypeArtifactId=scala-archetype-simple -DarchetypeVersion=1.0 -DremoteRepositories=http://scala-tools.org/repo-releases -DgroupId=au.com.belmonttechnology -DartifactId=scala-spring-hibernate

注意：建议使用命令行创建工程，不要使用idea创建工程。如果使用idea创建工程，可能不同版本的idea创建的工程有差异。

mvn clean package -Dmaven.test.skip=true

错误：这里写图片描述
解决办法：替换pom文件中<build>为以下内容：

<build>
    <plugins>
      <plugin>
        <groupId>net.alchim31.maven</groupId>
        <artifactId>scala-maven-plugin</artifactId>
        <version>3.2.0</version>
        <executions>
          <execution>
            <id>compile</id>
            <goals>
              <goal>compile</goal>
            </goals>
            <phase>process-resources</phase>
          </execution>
          <execution>
            <id>test-compile</id>
            <goals>
              <goal>testCompile</goal>
            </goals>
            <phase>process-test-resources</phase>
          </execution>
        </executions>
        <configuration>
          <scalaVersion>${scala.version}</scalaVersion>
        </configuration>
      </plugin>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-compiler-plugin</artifactId>
        <version>3.1</version>
        <configuration>
          <source>1.7</source>
          <target>1.7</target>
        </configuration>
      </plugin>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-resources-plugin</artifactId>
        <version>2.6</version>
      </plugin>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-surefire-plugin</artifactId>
        <version>2.17</version>
        <configuration>
          <skip>true</skip>
        </configuration>
        <executions>
          <execution>
            <id>unit-tests</id>
            <phase>test</phase>
            <goals>
              <goal>test</goal>
            </goals>
            <configuration>
              <skip>false</skip>
              <includes>
                <include>**/*Test.class</include>
                <include>**/*Spec.class</include>
              </includes>
              <excludes>
                <exclude>**/webtest/**/*Test.class</exclude>
              </excludes>
            </configuration>
          </execution>
          <execution>
            <id>web-tests</id>
            <phase>integration-test</phase>
            <goals>
              <goal>test</goal>
            </goals>
            <configuration>
              <skip>false</skip>
              <includes>
                <include>**/webtest/**/*Test.class</include>
              </includes>
            </configuration>
          </execution>
        </executions>
      </plugin>
      <plugin>
        <groupId>org.eclipse.jetty</groupId>
        <artifactId>jetty-maven-plugin</artifactId>
        <version>9.2.2.v20140723</version>
        <!-- If you can't use Java 7 for some reason, or want to use Jetty 8, check out the java-6 git branch -->
        <configuration>
          <httpConnector>
            <port>9090</port>
          </httpConnector>
          <stopKey>stopIt</stopKey>
          <stopPort>9191</stopPort>
          <reload>manual</reload>
          <systemProperties>
            <!-- Without this, JSPs don't compile when Maven runs on a JRE instead of a JDK (e.g. Java 7 on a Mac!) -->
            <systemProperty>
              <name>org.apache.jasper.compiler.disablejsr199</name>
              <value>true</value>
            </systemProperty>
          </systemProperties>
        </configuration>
        <executions>
          <execution>
            <id>start-jetty-before-integration-tests</id>
            <phase>pre-integration-test</phase>
            <goals>
              <goal>run</goal>
            </goals>
            <configuration>
              <scanIntervalSeconds>0</scanIntervalSeconds>
              <daemon>true</daemon>
            </configuration>
          </execution>
          <execution>
            <id>stop-jetty-after-integration-tests</id>
            <phase>post-integration-test</phase>
            <goals>
              <goal>stop</goal>
            </goals>
          </execution>
        </executions>
      </plugin>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-eclipse-plugin</artifactId>
        <version>2.9</version>
        <configuration>
          <additionalBuildcommands>
            <buildcommand>org.springframework.ide.eclipse.core.springbuilder</buildcommand>
            <buildcommand>org.eclipse.m2e.core.maven2Builder</buildcommand>
          </additionalBuildcommands>
          <additionalProjectnatures>
            <projectnature>org.springframework.ide.eclipse.core.springnature</projectnature>
            <projectnature>org.eclipse.m2e.core.maven2Nature</projectnature>
          </additionalProjectnatures>
          <buildcommands>
            <buildcommand>org.scala-ide.sdt.core.scalabuilder</buildcommand>
          </buildcommands>
          <classpathContainers>
            <classpathContainer>org.scala-ide.sdt.launching.SCALA_CONTAINER</classpathContainer>
            <classpathContainer>org.eclipse.jdt.launching.JRE_CONTAINER</classpathContainer>
          </classpathContainers>
          <downloadSources>true</downloadSources>
          <downloadJavadocs>true</downloadJavadocs>
          <excludes>
            <exclude>org.scala-lang:scala-library</exclude>
            <exclude>org.scala-lang:scala-compiler</exclude>
          </excludes>
          <projectnatures>
            <projectnature>org.scala-ide.sdt.core.scalanature</projectnature>
            <projectnature>org.eclipse.jdt.core.javanature</projectnature>
          </projectnatures>
          <sourceIncludes>
            <sourceInclude>**/*.scala</sourceInclude>
          </sourceIncludes>
          <wtpversion>2.0</wtpversion>
        </configuration>
      </plugin>
    </plugins>
  </build>

2 在IDEA引入工程，并使用scala

引入工程，修改App.scala为以下内容：

object App {
def main(args: Array[String]) {
println( "Hello World!" );
}
}

修改scala版本：

<scala.version>2.11.7</scala.version>

右键，Run ‘App’

3 创建web工程

修改pom文件<packaging>为war

<packaging>war</packaging>

在pom文件的中添加以下内容：

<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <org.springframework.version>4.0.6.RELEASE</org.springframework.version>
    <slf4j.version>1.7.7</slf4j.version>

替换pom文件的<dependencies>为以下内容：

<dependencies>
    <dependency>
      <groupId>org.scala-lang</groupId>
      <artifactId>scala-library</artifactId>
      <version>${scala.version}</version>
    </dependency>

    <dependency>
      <groupId>xerces</groupId>
      <artifactId>xercesImpl</artifactId>
      <version>2.9.1</version>
      <scope>runtime</scope>
    </dependency>

    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
      <scope>test</scope>
    </dependency>

    <dependency>
      <groupId>org.hibernate</groupId>
      <artifactId>hibernate-validator</artifactId>
      <version>5.1.2.Final</version>
      <scope>compile</scope>
    </dependency>

    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>${org.springframework.version}</version>
      <scope>compile</scope>
    </dependency>

    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-orm</artifactId>
      <version>${org.springframework.version}</version>
      <scope>compile</scope>
    </dependency>

    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-web</artifactId>
      <version>${org.springframework.version}</version>
      <scope>compile</scope>
    </dependency>

    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-webmvc</artifactId>
      <version>${org.springframework.version}</version>
      <scope>compile</scope>
    </dependency>

    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>javax.servlet-api</artifactId>
      <version>3.0.1</version>
      <scope>provided</scope>
    </dependency>

    <dependency>
      <groupId>javax.servlet.jsp</groupId>
      <artifactId>javax.servlet.jsp-api</artifactId>
      <version>2.2.1</version>
      <scope>provided</scope>
    </dependency>

    <dependency>
      <groupId>javax.servlet.jsp.jstl</groupId>
      <artifactId>javax.servlet.jsp.jstl-api</artifactId>
      <version>1.2.1</version>
      <scope>provided</scope>
    </dependency>

    <dependency>
      <groupId>commons-logging</groupId>
      <artifactId>commons-logging</artifactId>
      <version>1.2</version>
      <scope>runtime</scope>
    </dependency>

    <dependency>
      <groupId>org.slf4j</groupId>
      <artifactId>slf4j-api</artifactId>
      <version>${slf4j.version}</version>
      <scope>runtime</scope>
    </dependency>

    <dependency>
      <groupId>org.slf4j</groupId>
      <artifactId>slf4j-log4j12</artifactId>
      <version>${slf4j.version}</version>
      <scope>runtime</scope>
    </dependency>

    <dependency>
      <groupId>org.hibernate</groupId>
      <artifactId>hibernate-core</artifactId>
      <version>4.3.6.Final</version>
      <scope>compile</scope>
    </dependency>

    <dependency>
      <groupId>org.javassist</groupId>
      <artifactId>javassist</artifactId>
      <version>3.18.2-GA</version>
      <scope>runtime</scope>
    </dependency>

    <dependency>
      <groupId>c3p0</groupId>
      <artifactId>c3p0</artifactId>
      <version>0.9.1.2</version>
    </dependency>

    <dependency>
      <groupId>org.hsqldb</groupId>
      <artifactId>hsqldb</artifactId>
      <version>2.3.2</version>
      <scope>runtime</scope>
    </dependency>

    <dependency>
      <groupId>org.seleniumhq.selenium</groupId>
      <artifactId>selenium-java</artifactId>
      <version>2.42.2</version>
      <scope>test</scope>
    </dependency>

    <dependency>
      <groupId>com.google.code.findbugs</groupId>
      <artifactId>jsr305</artifactId>
      <version>1.3.9</version>
    </dependency>

  </dependencies>

创建src/main/webapp/WEB-INF目录，并创建web.xml文件，修改内容如下：

<?xml version="1.0" encoding="UTF-8"?>
<!--
 * This code is in the public domain and may be used in any way you see fit, with the following conditions:
 *
 *     THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 *     IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 *     FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 *     AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 *     LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 *     OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 *     THE SOFTWARE.
 -->
<web-app xmlns="http://java.sun.com/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
         id="scala-spring-hibernate"
         version="2.5">

    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>/WEB-INF/spring-context-data.xml</param-value>
    </context-param>

    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>

    <servlet>
        <servlet-name>dispatcher</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>/WEB-INF/spring-context-web.xml</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>

    <servlet-mapping>
        <servlet-name>dispatcher</servlet-name>
        <url-pattern>*.html</url-pattern>
    </servlet-mapping>

    <filter>
        <!-- Allows the "_method" parameter to dictate the HTTP method -->
        <filter-name>methodFilter</filter-name>
        <filter-class>org.springframework.web.filter.HiddenHttpMethodFilter</filter-class>
    </filter>

    <filter-mapping>
        <filter-name>methodFilter</filter-name>
        <url-pattern>*.html</url-pattern>
    </filter-mapping>


    <welcome-file-list>
        <welcome-file>index.jsp</welcome-file>
    </welcome-file-list>

</web-app>

添加spring-context-web.xml和spring-context-data.xml

在src/resources目录下，添加log4j.properties文件

编写scala、jsp代码，jetty:run启动web应用，在浏览器输入localhost:9090访问

项目代码:git@github.com:weimengchao/scala-spring-hibernate.git

wei542657623
关注
专栏目录
scala spring_Scala和Spring：结合两全其美
cunfu6353的博客
07-10 2093
spring scala 介绍 Scala是一种很棒的编程语言，它结合了简洁明了的语法以及与Java完全兼容的面向对象和功能编程范式的无缝融合。 后者使得将Scala与Java开发人员熟悉的Java API和框架结合起来成为可能。 这样，可以改善和简化现有Java框架的使用。 除此之外，Scala的学习门槛也降低了，因为它可以轻松地与“ Java的知名世界”集成。 在本文中，我将展示如何...
loan_reporter:示例应用程序，用于测试Scala，Play，Maven和Spring框架之间的集成
05-12
《构建集成Scala、Play、Maven与Spring框架的贷款报告应用》 在现代软件开发中，集成多种技术栈可以提高应用程序的灵活性和可扩展性。本文将深入探讨一个名为"loan_reporter"的示例应用程序，它巧妙地结合了Scala、...
Scala与Spring：强强联合(转)
天涯何处是我家
08-05 412
Scala是门优秀的编程语言，它将简洁、清晰的语法与面向对象和函数式编程范式无缝融合起来，同时又完全兼容于Java，这样Scala就能使用Java开发者所熟知的Java API和众多的框架了。在这种情况下，我们可以通过Scala改进并简化现有的Java框架。此外，Scala的学习门槛也非常低，因为我们可以轻松将其集成到“众所周知的Java世界中”。 由ThoughtWorks主...
spring scala
KimmKing的技术博客
05-14 3460
集成spring与scala https://github.com/SpringSource/spring-scala/wiki 主要功能： 1、在xml配置中使用scala beans 2、在xml配置中使用scala collections 3、通过scala代码装配对象 4、在scala中引入spring template：jdbc、jms、rest、transact
SpringBoot使用Scala进行Web开发
阿靖的博客
11-29 1636
Scala是一门多范式的编程语言，一种类似Java的编程语言，设计初衷是实现可伸缩的语言并集成面向对象编程。Scala把Erlang风格的基于actor的并发带进了JVM，开发者可以利用Scala的actor模型在JVM上设计具伸缩性的并发应用程序，它会自动获得多核心处理器带来的优势，而不必依照复杂的Java线程模型来编写程序，接下来就介绍一下如何在SpringBoot框架中使用Scala来进行简...
简化基于Scala的Web API开发
unber的博客
12-08 857
虽然说使用 Scala 语言的语法来写 SpringBoot 微服务已经可以让 Scala 开发者们兴奋不已了，但说实话，这并没有很大程度上发挥二者各自的最大威力。
SpringsScala：在Scala中创建Springs Web服务的示例项目
02-04
Scala可以与Spring的生态系统一起使用，以构建高度可扩展的，强大的Web应用程序。 该示例应用程序说明了如何在Scala中使用Spring。 用法 生成并启动应用程序。 cd SpringsScala / mvn spring-boo
Spring 整合 Scala 编程【转】
03-22
标题 "Spring 整合 Scala 编程【转】" 暗示了本文将探讨如何在Spring框架中使用Scala语言进行编程。Scala是一种强大的、面向对象且支持函数式编程的编程语言，它与Java虚拟机（JVM）兼容，因此可以无缝集成到Spring...
SpringBoot整合Scala构建Web服务的方法
08-26
在本教程中，我们将探讨如何将Scala语言与Spring Boot框架结合，用于构建高效且灵活的Web服务。Spring Boot因其简洁的配置和开箱即用的功能而受到广大开发者的喜爱，而Scala则是一种强大的多范式编程语言，它结合了...
SpringBoot + SpringData Jpa + Scala + Mysql（java+Scala混编）
11-20
SpringData JPA是Spring框架的一个模块，用于简化JPA（Java Persistence API）的使用。它提供了一个统一的API来访问各种持久化技术，如Hibernate、EclipseLink等。通过SpringData JPA，你可以利用注解驱动的方法来...
使用scala搭建 Spring boot 框架
weixin_30384217的博客
07-25 676
使用scala搭建 Spring boot 框架 1. 前言 spring boot是java开发平台上最流行的web框架。Scala是在JVM上运行的静态类型的函数编程语言。大数据处理Spark框架就是Scala语言开发的。 本例子将spring boot框架集成到scala项目中。利用Spring security模块提供的用户权限管理。制作一个简单的用户登录及权限管理。 使用到的技...
Scala中Spring常用的操作
weixin_37536020的博客
06-07 259
Scala中Spring常用的操作
Play之Scala-Web项目运行流程-简单分析（3）
liuzx32的专栏
04-22 1862
（2）中只是对简单的流程进行了分析，并没有涉及到play模板的内容，本文就是针对模板概念力图阐述 现在几乎每个web语言都会有这样那样的模板供你选择，如果你曾经使用过任何一种模板，我想模板这个概念你能很清晰的阐明，我借用类与对象的关系进行阐述：模板的功能就是将（含有模板元素的）页面实例化输出。每个人对模板的概念都不一而同，但模板干的事情几乎都是一致的--渲染页面! Play的模板在
Scalatra - 快速、简洁的Scala Web框架
最新发布
gitblog_00003的博客
03-07 1119
Scalatra: 极简、轻量级的Scala Web框架 Scalatra是一个基于Scala编写的极简、轻量级Web框架。它旨在提供一种简洁且易于理解的方式来构建高效、可扩展的Web应用程序。通过Scalatra，你可以快速地开发出具有RESTful API支持的Web应用。 项目简介 Scalatra 是一个基于Servlet API的Scala Web框架。它的设计灵感来自于Sinatra（...
Scala的四种Web框架
春华秋实
08-14 5531
Finatra Finatra是基于 Twitter-server platform平台, 运行在Finagle之上, 它是一个完整的异步框架。   Play Framework Play框架是一个Java 和 Scala的产品化Web应用框架，集成了各种开发Web应用需要的组件和API，本站Play框架专题   Scalatra Scalatra 是特别小巧的Web框架，也
Scala --Web记（SpringBoot + SpringDataJpa + Scala）
灰客
11-20 567
1.Controller import com.scala.domain.MetaTable import com.scala.service.MetaTableService import com.scala.utils.ResultVOUtil import org.springframework.beans.factory.annotation.Autowired import org....
springboot的maven打包和scala项目maven打包
name_szd的博客
06-19 1099
springboot中build配置：        &lt;build&gt;                &lt;!-- war的名称 --&gt; &lt;finalName&gt;demo&lt;/finalName&gt; &lt;plugins&gt;                        &lt;!-- 创建springboot项目后自动生成的build打包配置 --&...
在Javaweb中使用Scala
weixin_30869099的博客
03-19 130
Java 是一门比较优秀的编程语言， 其最大功劳是建立非常繁荣的JVM平台生态。不过 Java 语法比较麻烦，写过 C, Python 的人总是想使用简洁的语法，又希望利用上 Java 平台的强大，因此，催生了 Groovy , Scala 这样的 JVM 语言。那么为什么选择 Scala 呢？ 因为 Scala 是一门富有想象力的语言！ 　　本文尝试在 Javaweb...
web开发的前途
武之为大 草木皆兵
04-20 131
如果不是个人独自搞开发,搞研究,那么很容易走进后台开发的迷茫状态.很多东西只用三个键就完成了:ctrl,C,V 但是用于展现层的东西,却是百写不厌. css里完成布局的那一刹那,看到简洁的代码,心里很舒服. js的千变万化更是不用说了. 所以,没有时间升级你的开发框架或者升级你的java等级的时候,学习一下web开发吧.乐趣无穷....
学习Spring Boot，快速构建独立运行的基于Spring的项目
使用Spring Boot可以轻松创建一个独立运行的基于Spring框架的项目，而无需依赖外部的Servlet容器，并且无需将应用打包为WAR文件，而是可以将项目直接打包为可运行的JAR文件。此外，Spring Boot还提供了一系列starter...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值