Saved searches
Use saved searches to filter your results more quickly
You signed in with another tab or window. Reload to refresh your session. You signed out in another tab or window. Reload to refresh your session. You switched accounts on another tab or window. Reload to refresh your session.
License
pippo-java/pippo
This commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.
Name already in use
A tag already exists with the provided branch name. Many Git commands accept both tag and branch names, so creating this branch may cause unexpected behavior. Are you sure you want to create this branch?
Sign In Required
Please sign in to use Codespaces.
Launching GitHub Desktop
If nothing happens, download GitHub Desktop and try again.
Launching GitHub Desktop
If nothing happens, download GitHub Desktop and try again.
Launching Xcode
If nothing happens, download Xcode and try again.
Launching Visual Studio Code
Your codespace will open once ready.
There was a problem preparing your codespace, please try again.
Latest commit
Git stats
Files
Failed to load latest commit information.
README.md
It’s an open source (Apache License) micro web framework in Java, with minimal dependencies and a quick learning curve.
The goal of this project is to create a micro web framework in Java that should be easy to use and hack.
The size of pippo-core is only 140 KB and the size of pippo-controller (optional) is only 45 KB.
First we must create an Application and add some routes:
public class BasicApplication extends Application < @Override protected void onInit() < // send 'Hello World' as response GET("/", routeContext -> routeContext.send("Hello World")); // send a file as response GET("/file", routeContext -> routeContext.send(new File("pom.xml"))); // send a json as response GET("/json", routeContext -> < Contact contact = createContact(); routeContext.json().send(contact); >); // send xml as response GET("/xml", routeContext -> < Contact contact = createContact(); routeContext.xml().send(contact); >); // send an object and negotiate the Response content-type, default to XML GET("/negotiate", routeContext -> < Contact contact = createContact(); routeContext.xml().negotiateContentType().send(contact); >); // send a template with name "hello" as response GET("/template", routeContext -> < routeContext.setLocal("greeting", "Hello"); routeContext.render("hello"); >); > private Contact createContact() < return new Contact() .setId(12345) .setName("John") .setPhone("0733434435") .setAddress("Sunflower Street, No. 6"); > >
where Contact is a simple POJO:
public class Contact < private int id; private String name; private String phone; private String address; // getters and setters >
The second step is to choose your favorite server, template engine and content type engine.
For example, I will choose Jetty as server, Freemarker as template engine, Jackson as JSON engine and JAXB as XML engine.
My Maven pom.xml looks like:
dependency> groupId>ro.pippogroupId> artifactId>pippo-coreartifactId> version>$ version> dependency> dependency> groupId>ro.pippogroupId> artifactId>pippo-jettyartifactId> version>$ version> dependency> dependency> groupId>ro.pippogroupId> artifactId>pippo-freemarkerartifactId> version>$ version> dependency> dependency> groupId>ro.pippogroupId> artifactId>pippo-jacksonartifactId> version>$ version> dependency>
The last step it’s to start Pippo with your application as parameter:
public class BasicDemo < public static void main(String[] args) < Pippo pippo = new Pippo(new BasicApplication()); pippo.start(); > >
Pippo launches the embedded web server (found in your classpath) and makes the application available on port 8338 (default value). Open your internet browser and check the routes declared in Application:
- http://localhost:8338
- http://localhost:8338/file
- http://localhost:8338/json
- http://localhost:8338/xml
- http://localhost:8338/negotiate
- http://localhost:8338/template
@Path("/contacts") @Logging public class ContactsController extends Controller < private ContactService contactService; public ContactsController() < contactService = new InMemoryContactService(); > @GET @Named("index") // @Produces(Produces.HTML) @Metered @Logging public void index() < // inject "user" attribute in session getRouteContext().setSession("user", "decebal"); // send a template with name "contacts" as response getResponse() .bind("contacts", contactService.getContacts()) .render("contacts"); > @GET("/uriFor/") @Named("uriFor") @Produces(Produces.TEXT) @Timed public String uriFor(@Param int id, @Header String host, @Session String user) < System.out.println("id pl-s1">id); System.out.println("host pl-s1">host); System.out.println("user pl-s1">user); MapString, Object> parameters = new HashMap<>(); parameters.put("id", id); String uri = getApplication().getRouter().uriFor("api.get", parameters); return "id pl-s1">id + "; uri pl-s1">uri; > @GET("/api") @Named("api.getAll") @Produces(Produces.JSON) @NoCache public ListContact> getAll() < return contactService.getContacts(); > @GET("/api/") @Named("api.get") @Produces(Produces.JSON) public Contact get(@Param int id) < return contactService.getContact(id); > >
@Path("/files") public class FilesController extends Controller < @GET public void index() < // send a template with name "files" as response getRouteContext().render("files"); > @GET("/download") public File download() < // send a file as response return new File("pom.xml"); > @POST("/upload") @Produces(Produces.TEXT) public String upload(FileItem file) < // send a text (the info about uploaded file) as response // return file.toString(); return new StringBuilder() .append(file.getName()).append("\n") .append(file.getSubmittedFileName()).append("\n") .append(file.getSize()).append("\n") .append(file.getContentType()) .toString(); > >
Add controller(s) in your application:
public class BasicApplication extends ControllerApplication < @Override protected void onInit() < addControllers(ContactsController.class); // one instance for EACH request // OR addControllers(new ContactsController()); // one instance for ALL requests addControllers(FilesController.class); > >
Don’t forget that the Controller concept is included in pippo-controller module so you must add this module as dependency in your project.
Documentation is available on pippo.ro
Demo applications are available on pippo-demo
For a real life application built with Pippo please look at Web Accounting — Pippo Demo
Spark — A micro framework for creating web applications in Kotlin and Java 8 with minimal effort
Spark is sponsored by Feature Upvote. A big thanks to them for helping the project to grow.
Built for productivity
Spark Framework is a simple and expressive Java/Kotlin web framework DSL built for rapid development. Sparks intention is to provide an alternative for Kotlin/Java developers that want to develop their web applications as expressive as possible and with minimal boilerplate. With a clear philosophy Spark is designed not only to make you more productive, but also to make your code better under the influence of Spark’s sleek, declarative and expressive syntax.
Lets you take full advantage of the JVM
The JVM offers one of the biggest programming ecosystems in the world. It has a lot of Java web frameworks, but pure Java web development has traditionally been very cumbersome. If you love the JVM, but hate verbose code and frameworks, Spark is the web framework for you. It will have you up and running in minutes, and you can even use it with Groovy or Kotlin or whatever you want. Spark is an expressive, lightweight and unopinionated pure Java (and Kotlin) web framework that doesn’t get in your way, unlike in other web frameworks, you can structure your application as you want.
Microservices, microservices everywhere!
2015 was the year of microservice hype, and now that you’re getting around to looking into it you’re about to realize that Spark is great for microservices. Microservices work best with micro frameworks, and Spark has your REST API ready to serve JSON in less than ten lines of code. Spark is mainly used for creating REST API’s, but it also supports a multitude of template engines. Why not create one Spark application for your backend and one for your frontend?
Some companies using Spark:
NodeJS developer? Using TypeScript? Try Spark instead!
Lately, a lot of server-side web development has been taken over by NodeJS, but a growing number of NodeJS developers are using TypeScript and other statically typed languages that compile to JavaScript. Why not go all the way and use a language that was actually designed with types, and intended to run on the server-side? You also get all the benefits of running your application on the JVM, where libraries aren’t deprecated every day. If you’re coming from ExpressJS, then Spark’s syntax will feel very familiar, and unlike a lot of JavaScript web frameworks, Spark won’t be deprecated tomorrow.
Typical usage
Our 2015 survey tells us that over 50% of Spark users use Spark to create REST APIs, while about 25% use Spark to create websites. About 15% of deployed Spark applications each serve more than 10.000 users a day. Click here to read the full survey.
Spark Framework is a free and open source Java Web Framework, released under the Apache 2 License | Contact | Team