java调用scala程序

用Java在各种框架下编译Scala项目

在IDE上的设置

首先 下载的IntelliJ IDEA的 x（社区版） 因为目前它是最好的Scala的IDE 然后选择File |设置|插件 选择可用的选项卡来安装Scala插件

创建Maven项目

在IntelliJ IDEA中 选择文件|新建项目 然后选择Maven的模块创建一个Maven项目 然后修改如下所示的pom xml 添加所有你需要的设置 建立Scala的汇编语言

project xmlnsxmlns= xmlns:xsi= instance

         xsi:schemaLocation= v _ _ xsd

    modelVersion /modelVersion

    groupId foo/groupId

    artifactIdmyapp/artifactId

    packagingwar/packaging

    version SNAPSHOT/version

    namemyapp Java EE Webapp/name

    url;/url

    properties

        spring version RELEASE/spring version

     /properties

    repositories

        repository

            id /id

            nameRepository hosting the jee artifacts/name

            url;/url

         /repository

        repository

            id/id

             nameScala tools Maven Repository/name

            url;/url

        /repository

        repository

             idwpt release/id

            url repo/releases/url

        /repository

        repository

             idwpt snapshot/id

            url repo/snapshots/url

        /repository

    /repositories

    pluginRepositories

        pluginRepository

            id/id

            nameScala tools Maven Repository/name

            url;/url

         /pluginRepository

    /pluginRepositories

    dependencyManagement

        dependencies

            dependency

                 groupId springframework/groupId

                artifactIdspring context/artifactId

                version${spring version}/version

             /dependency

             dependency

                groupId springframework/groupId

                artifactIdspring core/artifactId

                version${spring version}/version

            /dependency

            dependency

                groupId springframework/groupId

                 artifactIdspring web/artifactId

                version${spring version}/version

             /dependency

             dependency

                groupId springframework/groupId

                 artifactIdspring orm/artifactId

                version${spring version}/version

            /dependency

        /dependencies

    /dependencyManagement

    dependencies

        dependency

            groupId h database/groupId

            artifactIdh /artifactId

            version /version

        /dependency

        dependency

             groupId hibernate/groupId

            artifactIdhibernate entitymanager/artifactId

            version GA/version

        /dependency

        dependency

            groupId springframework/groupId

            artifactIdspring orm/artifactId

        /dependency

        dependency

            groupIddev/groupId

            artifactIdwpt core/artifactId

            version SNAPSHOT/version

            scopetest/scope

        /dependency

        dependency

            groupIddev/groupId

            artifactIdwpt runtime spring/artifactId

             version SNAPSHOT/version

        /dependency

        dependency

             groupIdjavax/groupId

            artifactIdjavaee web api/artifactId

            version /version

            scopeprovided/scope

        /dependency

        dependency

            groupIdjunit/groupId

            artifactIdjunit/artifactId

            version /version

            scopetest/scope

        /dependency

        dependency

            groupId scala lang/groupId

            artifactIdscala library/artifactId

            version RC /version

        /dependency

        dependency

            groupId apache wicket/groupId

            artifactIdwicket/artifactId

            version /version

        /dependency

        dependency

            groupId slf j/groupId

            artifactIdslf j log j /artifactId

            version /version

        /dependency

    /dependencies

    build

        pluginManagement

            plugins

                 plugin

                    groupId apache maven plugins/groupId

                    artifactIdmaven piler plugin/artifactId

                     version /version

                /plugin

                plugin

                     groupId scala tools/groupId

                    artifactIdmaven scala plugin/artifactId

                    version /version

                /plugin

            /plugins

        /pluginManagement

        plugins

            plugin

                 groupId apache maven plugins/groupId

                artifactIdmaven piler plugin/artifactId

                executions

                    execution

                        phasepile/phase

                        goals

                            goalpile/goal

                        /goals

                    /execution

                /executions

                configuration

                    source /source

                    target /target

                /configuration

            /plugin

            plugin

                groupId apache maven plugins/groupId

                 artifactIdmaven war plugin/artifactId

                version beta /version

                configuration

                    failOnMissingWebXmlfalse/failOnMissingWebXml

                 /configuration

            /plugin

            plugin

                 groupId scala tools/groupId

                artifactIdmaven scala plugin/artifactId

                executions

                    execution

                         idscala pile first/id

                        phaseprocess resources/phase

                         goals

                            goaladd source/goal

                            goalpile/goal

                        /goals

                    /execution

                    execution

                         idscala test pile/id

                        phaseprocess test resources/phase

                         goals

                            goaltestCompile/goal

                        /goals

                    /execution

                /executions

            /plugin

        /plugins

        finalNamemyapp/finalName

    /build

/project

web xml中设置

接下来 修改main/webapp/WEB INF/web xml 从而确立了Wicket的过滤器 打开Spring的JPA实体管理器和Spring监听器 进行Spring的初始化

?xml version= encoding= UTF ?

web app version= xmlns= xmlns:xsi= instance

         xsi:schemaLocation= app_ _ xsd

     filter

         filter namef /filter name

        filter class springframework orm jpa support OpenEntityManagerInViewFilter/filter class

    /filter

    filter

         filter namef /filter name

        filter class apache wicket protocol WicketFilter/filter class

         init param

            param nameapplicationClassName/param name

            param value foo myapp MyApp/param value

         /init param

    /filter

    filter mapping

        filter namef /filter name

        url pattern/app/*/url pattern

    /filter mapping

    filter mapping

        filter namef /filter name

        url pattern/*/url pattern

    /filter mapping

    context param

        param namecontextConfigLocation/param name

        param valueclasspath:/beans xml/param value

    /context param

    listener

        listener class sprntext ContextLoaderListener/listener class

     /listener

/web app

设置Spring bean访问和调用的数据库

要定义这些Spring bean 创建main/resources的beans xml以及一下的内容

?xml version= encoding= UTF ?

beansxmln *** eansxmlns=

        xmlns:xsi= instance

       xmlns:context=

        xmlns:tx=

       xsi:schemaLocation=

        beans xsd

        context xsd

        tx xsd

     context:ponent scan base package= foo myapp /

    bean id= emf class= springframework orm jpa LocalContainerEntityManagerFactoryBean

        property name= persistenceXmlLocation value= classpath:/META INF/my persistence xml /

     /bean

    bean id= transactionManager class= springframework orm jpa JpaTransactionManager

        property name= entityManagerFactory ref= emf /

     /bean

    tx:annotation driven /

/beans

读取数据库配置中persistence xml文件 在这里 您将获得一个主目录中名为MyApp的H 数据库 因此 创建main/resources/META INF文件的内容如下

persistencexmlnspersistencexmlns=

            xmlns:xsi= instance

            xsi:schemaLocation= _ _ xsd

             version=

   persistence unit name= myapp transaction type= RESOURCE_LOCAL

        provider hibernate ejb HibernatePersistence/provider

        properties

           propertynamepropertyname= nnection driver_class value= h Driver /

           property name= nnection url value= jdbc:h :tcp://www.easyaq.com/~/myapp /

            propertynamepropertyname= nnection username value= sa /

            propertynamepropertyname= nnection password value= /

           property name= hibernate dialect value= hibernate dialect H Dialect /

           property name= hibernate hbm ddl auto value= create /

        /properties

   /persistence unit

/persistence

创建Wicket的页面

在这里 您将创建一个Wicket页面显示从数据库加载一些内容 因此 创建主/Scala文件夹 右键单击它并选择新建|Scala类 命名为我的页面类和投入 foo myapp包中 如下所示

package foo myapp

import apacl _

import basic Label

import list {ListItem ListView}

import apache wicket spring injection annot SpringBean

import apache wicket model CompoundPropertyModel

class MyPage extends WebPage {

  @SpringBean

   var ps: ProductService = _

  val productListView = newListView[Product]( productListView ps getAll) {

     def populateItem(item: ListItem[Product]) = {

      item setModel(newCompoundPropertyModel[Product](item getDefaultModelObject))

      item add(new Label( name ))

      item add(new Label( price ))

    }

  }

  add(productListView)

}

请注意 在创建ProductService对象加载的文件之后使用 此外 请注意该字段被分配到一个下划线（_） Scala编译为不可初始化的 而是留在默认状态 在你将覆盖作为编译之前 执行Spring bean的页面构造 现在 创建在src/main/resources//foo/myapp的的l文件

!DOCTYPE HTML PUBLIC //W C//DTD HTML Transitional//EN

    table border=

        tr wicket:id= productListView

            td wicket:id= name /td

            td wicket:id= price /td

        /tr

    /table

/

创建ProductService

右键单击在in the src/main/scala文件夹中的 foo myapp包并选择New | Scala的类 然后选择创建ProductService

package foo myapp

import java util List

trait ProductService {

  def getAll: List[Product]

}

这是接口 对创造一个DefaultProductService的Scala在同一个包内进行执行操作

package foo myapp

import javax persistence {PersistenceContext EntityManager}

import springframework stereotype {Service}

import springframework transaction annotation Transactional

import springframework beans factory annotation Autowired

@Service

@Transactional

class DefaultProductService extends ProductService {

  @Autowired

  var products: Products = _

  def getAll = products getAll

}

请注意 把它使用类型文件命名为DAO

创建文件的DAO

要创建的DAO 创建一个名为在同一文件夹

package foo myapp

import java util List

trait Products {

   def getAll: List[Product]

}

然后创建在同一文件夹中的执行Scala的DefaultProducts文件

package foo myapp

import javax persistence {PersistenceContext EntityManager}

import springframework stereotype Repository

import java util List

@Repository

class DefaultProducts extends Products {

  @PersistenceContext

  var em: EntityManager = _

  def getAll = {

    em createQuery( select p from Product p ) getResultList asInstanceOf[List[Product]]

  }

}

创建entity程序

创建entity程序并将其映射到数据库

package foo myapp

import javax persistence {GeneratedValue Id Entity}

@Entity

class Product {

  @Id

  @GeneratedValue

  var id: Long = _

  var name: String = _

  var price: Double = _

}

创建Wicket的应用程序

最后 创建在同一个MyApp的Scala程序

package foo myapp

import apache wicket protocol WebApplication

dev wicketpagetest MockableSpringBeanInjector

class MyApp extends WebApplication {

  def getHomePage = classOf[MyPage]

   override def init = {

    MockableSpringBeanInjector installInjector(this)

  }

}

在这里 您指定为首页我的目录 植入Spring Bean中

运行应用程序

随着IntelliJ IDEA的版本不断改进 您将嵌入到应用服务器运行您的应用程序 这非常容易 在刚刚创建的测试 foo myapp的ManualTest在刚刚创建的测试 foo myapp包一类ManualTest/scala文件（不是main/scala文件） 以下内容是

package foo myapp

dev wicketpagetest {WebAppJettyConfiguration WicketAppJettyLauncher}

object ManualTest {

  def main(args: Array[String]) {

    val l = new WicketAppJettyLauncher

    l startAppInJetty(new WebAppJettyConfiguration)

  }

}

要运行的应用程序 首先需要运行数据库服务器上的H 程序 所以 在下载和解压 然后变成h /bin和运行h bat（或在Linux上h sh） ManualTest是在IDEA的编辑器上 在IDEA选择运行DEA 它将运行ManualTest Jetty的运行您的应用程序

为了测试它 请尝试通过在浏览//www.easyaq.com: /app

不知道各位感觉如何 感谢各位支持！谢谢！

lishixinzhi/Article/program/Java/hx/201311/26175

如何将如下的java代码用scala写

@RunWith(Parameterized.class)

public class MeetingHttpApiTest extends TestBase {

@Test

public void testMeetingHttpApi() {

TedaCaseVo tedaCaseVo = tedaCaseService.getTedaCase(tedaCaseId);

String url = tedaCaseVo.getParamJsonStr();

TedaTool.record(tedaCaseVo, SwordHttp.get(url), tedaCaseService);

}

@Parameters

public static Collection data() {

return Arrays.asList(new Object[][]{{22L}, {23L}, {24L},{25L}, {26L}, {27L}});

}

public MeetingHttpApiTest(Long tedaCaseId) {

this.tedaCaseId = tedaCaseId;

}

protected Long tedaCaseId = 1L;

}

其中,TestBase类:

@SpringApplicationConfiguration(classes = Application.class)

@WebAppConfiguration

public class TestBase {

@Autowired

protected TedaCaseService tedaCaseService;

private TestContextManager testContextManager;

@Before

public void setUpContext() throws Exception {

this.testContextManager = new TestContextManager(getClass());

this.testContextManager.prepareTestInstance(this);

}

}

求助！scala如何调用java静态方法

Scala没有静态方法或静态字段，可以用object这个语法结构来达到同样的目的，对象定义了某个类的单个实例，包含了你想要的特性。

例如：

object Accounts{

private var lastNumber = 0

def newUniqueNumber()={lastNumber+=1;lastNumber}

}

当你在应用程序中需要一个新的唯一账号时，调用Account.newUniqueNumber()即可。

scala trait 接口java怎么使用

今天说一说Java中的接口和Scala中的trait。一直就把特质当做半个接口用，因为确实挺像的，但仔细看，还是有很大区别的。

1.接口不会有构造器，特质可以有构造器，并且在实现类继承特质的时候，先要调用特质的构造器。

trait构造器的调用顺序小结：

class B{}

trait C extends E{}

trait D extends E{}

A extends B with C with D

(1)先调用父类构造器B

(2)继承多个trait从从左至右依次执行，先调用父trait E构造器，再调用C，再调用D构造器

(3)如果多个trait继承同一个父trait，则父trait只执行一次

(4)所有父类构造器和trait构造器执行完毕之后再执行自己的构造器A

2.接口中不能有未初始化的属性，且属性的修饰都是public static final，特质中可以有未初始化的属性变量，即抽象字段；

未初始化的属性可以有提前定义的特性，有两种方法，例如：

trait A{

val name:String//抽象字段

println(“name: “+name)//特质中构造器执行的语句

}

class B extends A{

val name:String = “张三”

}

此时如果在main函数中new B的话，肯定会报错，因为new B必然先会调用特质中的构造器，而name并没有被赋值，所以会报错。有三种方法解决：

(1)class B extends {

val name:String = “张三” //提前定义在类前

} with A{}

(2)class B{}

main函数中new B的时候：

val b = new {

val name:String = “张三”//提前定义在new对象前

} with B with A

(3)利用lazy特性

trait A{

lazy val name:String = null

println(“name: “+name)

}

class B extends A{

override lazy val name:String = “张三”

}

scala.reflect.classtag java怎么传入

Java 和 Scala 都支持变参方法, 写在最后的位置上，最基本的调用方式也都是一样的，一个个罗列过去。也可以传入数组参数，因为变参本质上就是一个数组，就是把 … 开始位置到最后一个参数都收纳到数组中去，所以变参之所以要放在最后的位置上，且一个方法中最多只能有一个变参类型。

这里主要是对比 Scala 对变参方法的调用，基本调用法当然是没问题的，但是在传入数组作为变参的参数列表与 Java 相对时就稍有变化了。

另外提一下，如果想传入 List 作为变参列表，而不是整体作为变参的第一个元素就是调用集合的 toArray() 方法转换成一个数组传入。

下面看 Java 中对变参方法的调用，参数列表和数组

public class JavaVarArgs {

public static void main(String[] args) {

foo(“a”, “b”, “c”);

foo(new String[]{“d”, “e”});

}

public static void foo(String…params) {

System.out.println(params + ” : ” + params.length);

for(String s: params) {

System.out.println(s);

}

}

}

从输出结果能够很明白的看出变参 params 实际上就是一个数组

[Ljava.lang.String;@3f91beef : 3

a

b

c

[Ljava.lang.String;@1a6c5a9e : 2

d

e

我们知道 Scala 和 Java 之间可以互相调用，现在写一段 Scala 代码来调用 foo() 方法

object ScalaVarArgs {

def main(args: Array[String]) {

JavaVarArgs.foo(“a”, “b”, “c”)

// JavaVarArgs.foo(Array[String](“d”, “e”))

}

}

JavaVarArgs.foo(“a”, “b”, “c”) 调用没问题

而 JavaVarArgs.foo(Array[String](“d”, “e”)) 会有编译问题

Type mismatch: expected String, actual Array[String]

Java 在调用变参方法时可以直接传入相应类型的数组，而 Scala 确不允许这么做了，因它试图把 Array[String] 整体作为一个元素传递给 foo() 方法，而 foo() 要求的元素类型是字符串，所以编译不过。

而 Scala 这时该如何使得与 Java 调用变参方法时的行为一致呢，那就是在调用时再附加说明：是要把数组中的元素逐个传递级变参，写法

JavaVarArgs.foo(Array[String](“d”, “e”) :_*)

这样的调用输出就是

本文原始链接 , 来自隔叶黄莺 Unmi Blog

[Ljava.lang.String;@7a718e31 : 2

d

e

如果从上面的例子说来，我们的运气还不错，因为编译器告诉了你出现了什么问题。最麻烦的问题总是在能编译，但运行时诡异的情况。

因为在我本人实际中遭遇到的情形是变参类型是 Object 的方法，形如

public static void foo(Object…params) {

System.out.println(params + ” : ” + params.length);

for(Object o: params) {

System.out.println(o);

}

}

上面把参数改为 Object…params, 不会改变 Java 传数组调用它的行为，但却增加了 Scala 调用它时的排错难度。

在 Scala 中使用 foo(Array[String](“d”, “e”) 调用并没有编译错误，加入上面的调试代码才发现，不管传入多大的数组，总是输出像

[Ljava.lang.Object;@7814d044 : 1

[Ljava.lang.String;@ea25c1

说方法只接收到了一个元素，类型被识别为形参的类型，不过进一步遍历变参，发现第一个元素是一个字符串数组，所以 Scala 把 Array[String](“d”, “e”) 整体作为 params 的第一个元素传给了 foo() 方法。写成

foo(Array[String](“d”, “e”) : _*)

是为了把数组拆散了传给 foo() 方法。

起初以为是 Scala 调用 Java 的变参方法需要这么做，后来重新用 Scala 实现下变参方法

def foo(params: AnyRef*) {

println(params + ” : ” + params.length)

for (s – params) {

println(s)

}

}

用 Scala 代码来调用它，传入数组，如果不想整体作为一个元素时也必须加上 : _*参数说明，同样的：

foo(Array[String](“d”, “e”) :_*)

在写这篇之前，我所认定的这是 Scala 调用变参方法的一个缺陷， : _* 似乎是一种默认行为，现在认为这恰恰是 Scala 的一个灵活性所在。Scala 提供了两种方式来传递数组给变参，而为何 Java 不让数组整体作为变参的一个元素呢，不过 Scala 放开这一特性，当变参为 Object… params 确实放大了 Bug 的出现机率。