7.21 杭州源创会火热报名中,一起来看看移动开发如何紧跟浪潮?
Watch Star Fork

actframework / actframeworkJava

加入码云
与超过 300 万 开发者一起发现、参与优秀开源项目,私有仓库也完全免费 :)
免费加入
ActFramework是一种简洁易用,具有强大表达力的Java MVC全栈框架. http://actframework.org
Gelin Luo 最后提交于 update testapp
取消
提示: 由于 Git 不支持空文件夾,创建文件夹后会生成空的 .keep 文件
Loading...
README.md 10.06 KB

ACT Framework

Join the chat at https://gitter.im/actframework/actframework APL v2 Maven Central Build Status Javadocs Feature Requests

Install

Add act-starter-parent into into your pom.xml file

  <parent>
    <groupId>org.actframework</groupId>
    <artifactId>act-starter-parent</artifactId>
    <version>1.8.8.6</version>
  </parent>

Or use maven archetype to start an new project:

mvn archetype:generate -B \
    -DgroupId=com.mycom.helloworld \
    -DartifactId=helloworld \
    -DarchetypeGroupId=org.actframework \
    -DarchetypeArtifactId=archetype-quickstart \
    -DarchetypeVersion=1.8.8.7

To start an new project for RESTful service:

mvn archetype:generate -B \
    -DgroupId=com.mycom.helloservice \
    -DartifactId=helloservice \
    -DarchetypeGroupId=org.actframework \
    -DarchetypeArtifactId=archetype-simple-restful-service \
    -DarchetypeVersion=1.8.8.7

tips don't forget replace the groupId, artifactId and appName in the above script, or you can use interactive mode to generate your project:

mvn archetype:generate -DarchetypeGroupId=org.actframework -DarchetypeArtifactId=archetype-quickstart -DarchetypeVersion=1.8.8.7

Or

mvn archetype:generate -DarchetypeGroupId=org.actframework -DarchetypeArtifactId=archetype-simple-restful-service -DarchetypeVersion=1.8.8.7

For RESTful service project

Features

  • A full stack MVC framework

    • Actframework is NOT a servlet framework. Act app does not run in a servlet container. Instead it run as an independent Java application and it starts in seconds
  • Unbeatable development experience w/ great performance

    • Never restart your app when you are developing. Act's dev mode provides hot reloading feature makes it the dream of every Java web app developer. Check out this 3 mins video and feel it!
    • According to TechEmpower Framework Benchmark Act beats most full stack Java web framework on the market. In some cases Act can be over 10 times faster than Springboot
  • Fully JSR330 Dependency Injection support

    • ActFramework's DI support is built on top of Genie, a lightweight yet fast JSR330 implementation.
    • Benefit from Act's powerful class scan feature, it does not require the user to create injector from modules (as the usually way you use Guice). Declare your module and your binding is automatically registered
  • Superb SPA/Mobile app support

  • Uncompromising Security

  • Annotation aware but not annotation stack

    • Annotation is one of the tool ActFramework used to increase expressiveness. However we do not appreciate crazy annotation stacked code. Instead we make the code to express the intention in a natural way and save the use of annotation whenever possible.

      For example, for the following SpringMVC code:

      @RequestMapping(value="/user/{userId}/invoices", method = RequestMethod.GET)
      public List listUsersInvoices(
        @PathVariable("userId") int user,
        @RequestParam(value = "date", required = false) Date dateOrNull) {
          ...
      }
      

      The corresponding ActFramework app code is:

      @GetAction("/user/{user}/invoices")
      public List listUsersInvoices(int user, Date date) {
        ...
      }
      
  • Multi-environment configuration

    • ActFramework supports the concept of profile which allows you to organize your configurations in different environment (defined by profile) easily. Take a look at the following configurations from one of our real project:

      resources
        ├── conf
        │   ├── common
        │   │   ├── app.properties
        │   │   ├── db.properties
        │   │   ├── mail.properties
        │   │   ├── payment.properties
        │   │   └── social.properties
        │   ├── local-no-ui
        │   │   ├── app.properties
        │   │   ├── db.properties
        │   │   └── port.properties
        │   ├── local-sit
        │   │   └── app.properties
        │   ├── local-ui
        │   │   ├── app.properties
        │   │   └── db.properties
        │   ├── sit
        │   │   ├── app.properties
        │   │   └── db.properties
        │   └── uat
        ...
      

      Suppose on your UAT server, you start the application with JVM option -Dprofile=uat, ActFramework will load the configuration in the following sequence:

      1. Read all .properties files in the /resources/conf/common dir
      2. Read all .properties files in the /resources/conf/uat dir

      This way ActFramework use the configuration items defined in uat profile to overwrite the same items defined in common profile. The common items that are not overwritten still effective.

  • Simple yet powerful database support

  • Powerful view architecture with multiple render engine support

  • Commonly used tools

Sample code

A HelloWorld app

package demo.helloworld;

import act.Act;
import act.Version;
import org.osgl.mvc.annotation.GetAction;

public class HelloWorldApp {

    @GetAction
    public String sayHelloTo(@DefaultValue("World") String who) {
        return "Hello " + who + "!";
    }

    public static void main(String[] args) throws Exception {
        Act.start();
    }

}

See this 7 mins video on how to create HelloWorld in Eclipse from scratch. or for users without youtube access

A full RESTful service

package demo.rest;

import act.controller.Controller;
import act.db.morphia.MorphiaAdaptiveRecord;
import act.db.morphia.MorphiaDao;
import org.mongodb.morphia.annotations.Entity;
import org.osgl.mvc.annotation.*;

import java.util.Map;

import static act.controller.Controller.Util.notFoundIfNull;

@Entity("user")
public class User extends MorphiaAdaptiveRecord<User> {

    @UrlContext("user")
    public static class Service extends MorphiaDao<User> {

        @PostAction
        public User create(User user) {
            return save(user);
        }

        @GetAction
        public Iterable<User> list() {
            return findAll();
        }

        @GetAction("{id}")
        public User show(@DbBind("id") User user) {
            return user;
        }

        @PutAction("{id}")
        public User update(@DbBind("id") @NotNull User user, Map<String, Object> data) {
            user.mergeValues(data);
            return save(user);
        }

        @DeleteAction("{id}")
        public void delete(String id) {
            deleteById(id);
        }
    }

    public static void main(String[] args) throws Exception {
        Act.start();
    }

}

See this 1 hour video on RESTful support or for user without youtube access

See this 7 mins video to understand more about AdaptiveRecord or for user without youtube access

Background

I love PlayFramework v1.x because it is simple, clear and expressive. It brought us a completely different experience in web development with Java. However I don't totally agree with where Play 2.X is heading for, and it looks like I am not the only person with the concern as per this open letter to Play Framework Developers.

I have thought of rolling out something that could follow the road paved by Play 1.x, something that is simple, clear, expressive and Java (specifically) developer friendly. About one and half year after that I decide I could start the project seriously, and now another one and half year passed by, I've got this ACT framework in a relatively good shape.

Happy coding!

项目点评 ( 42 )

你可以在登录后,发表评论

11_float_left_people 11_float_left_close