GettingStarted

Configure jSqlBox

If use Java8 or above, add the following to the project's pom.xml file:

<dependency>
   <groupId>com.github.drinkjava2</groupId>
   <artifactId>jsqlbox</artifactId>
   <version>4.0.6.jre8</version> <!--or latest version-->
</dependency> 

If it is Java6 or 7 environment, add in pom.xml:

<dependency>
   <groupId>com.github.drinkjava2</groupId>
   <artifactId>jsqlbox</artifactId>
   <version>4.0.1.jre6</version> <!--or latest version-->
</dependency> 

Starting from version 4.0, jSqlBox no longer depends on any 3rd party dependencies, it only needs a separate jar to use, so after using jSqlBox, there is no need to add dependencies of DButils and jBeanBox in pom.xml. For beginners who want to understand the source code, or for users who want to customize development, you can also copy all the source code in the core\src\main\java directory of jSqlBox to the project, and you can use it directly.

jSqlBox works in auto-commit mode by default. If you want it to support transactions, please refer to the introduction of "Transaction Configuration" and several demonstration projects under the demo directory "jsqlbox-jfinal", "jsqlbox-springboot", "jsqlbox- "mybatis", "jsqlbox-actframework", etc.

If you are using Spring Boot, its configuration can be simplified to this:

public class MyAppDemo {
    @Autowired
    DataSource ds;

    public static void main (String [] args) {
        SpringApplication.run (MyAppDemo.class, args);
    }
   
    @Bean
    public DbContext createDefaultDbContext () {
      DbContext ctx = new DbContext (ds);
      ctx.setConnectionManager (SpringTxConnectionManager.instance ()); // Transaction manager
      DbContext.setGlobalDbContext (ctx); // Set static global context for ActiveRecord use
      return ctx;
    }
}

The code is very concise, but it is not easy for novices to understand it, because Spring Boot uses the default conventions in the background and does a lot of things (and also introduces many bloated libraries). This example is located in jsqlbox-springboot folder in the demo directory.

The first jSqlBox example:

Add the following dependencies in pom.xml:

    <dependency>
      <groupId>com.github.drinkjava2</groupId>
       <artifactId>jsqlbox</artifactId> 
       <version>4.0.6.jre8</version> <!--or latest version--> 
    </dependency>

    <dependency>
      <groupId>com.h2database</groupId>
      <artifactId>h2</artifactId> <!--H2 Database-->
      <version>1.3.176</version>
    </dependency>

Type the following program in the IDE and run it:

import javax.sql.DataSource;
import org.h2.jdbcx.JdbcConnectionPool;
import static com.github.drinkjava2.jsqlbox.DB.*;
import com.github.drinkjava2.jdialects.annotation.jdia.UUID25;
import com.github.drinkjava2.jdialects.annotation.jpa.Id;
import com.github.drinkjava2.jsqlbox.*; 
public class HelloWorld implements ActiveEntity<HelloWorld> {
  @Id
  @UUID25
  private String id;
  private String name;
  public String getId() {return id;}
  public void setId(String id) {this.id = id;}
  public String getName() {return name;}
  public HelloWorld setName(String name) {this.name = name;return this;}
	
  public static void main(String[] args) {
    DataSource ds = JdbcConnectionPool //use h2 database
      .create("jdbc:h2:mem:DBNameJava8;MODE=MYSQL;DB_CLOSE_DELAY=-1;TRACE_LEVEL_SYSTEM_OUT=0", "sa", "");
    DbContext ctx = new DbContext(ds);
    ctx.setAllowShowSQL(true); //allow SQL log
    DbContext.setGlobalDbContext(ctx); //set global DbContext
    ctx.quiteExecute(ctx.toDropAndCreateDDL(HelloWorld.class));//create table
    HelloWorld h = new HelloWorld().setName("Foo").insert().putField("name", "Hello jSqlBox").update();
    System.out.println(DB.iQueryForString("select name from HelloWorld where name like ?", param("H%"), " or name=",
				ques("1"), " or name =", ques("2")));
    h.delete();//delete entity
    ctx.executeDDL(ctx.toDropDDL(HelloWorld.class));//delete table
  }
}

Print out "Hello jSqlBox", indicating that a record was inserted in the in-memory database. Bingo! There is no garbage code like interface, implementation, Dao.

If the above example works in Java6, 7 environment, the 4.0.1.jre6 version should be introduced in the pom, and the implementations ActiveEntity should be changed to extends ActiveRecord. In the above example, ctx.quiteExecute (ctx.toDropAndCreateDDL (HelloWorld.class)); method converts the entity bean into a DDL script related to the dialect of the database and executes it. QuiteExecute means to ignore the errors in the execution, because some databases such as Oracle does not support exist checking in DDL.

To use jSqlBox, you must first create a DbContext instance, which has the following two construction methods: DbContext () DbContext (DataSource) When the constructor parameter is empty, it means to create a DbContext instance without a data source. In this case, because DbContext does not know where the data source is, you must add a Connection instance as a parameter to each method when using it, for example ctx.query (conn, "select * from users where name =?", "tom");

When there is a DataSource instance in the constructor parameter, it means to create a DbContext instance with a data source. In this case, the method does not require a Connection instance as a parameter, such as ctx.query ("select * from users where name =?", " tom ");

If someone used DbUtils before, may be familiar with the above usage. Because DbContext is a subclass of QueryRunner, it also has a constructor similar to QueryRunner of DbUtils and inherits all the methods of QueryRunner.

In complex situations, the settings of the DbContext instance, such as logs, templates, dialects, transactions, interceptors, etc., can be directly set its various options, such as ctx.setAllowShowSQL (true) will open the log output, for details, please refer to "jSqlBox configuration " chapter.

Note: Except for the unsafe configuration method of the DbContext instance (that is, methods such as setXxx and getXxx), all its other methods are thread-safe, so if there is only one data source, the entire project can only create one DbContext instance. And, usually this instance will also be configured as a global static instance, so you can use the static methods in the DB class to statically introduce the use, greatly simplifying programming. However, if you want to create a lot of DbContext instances, there is no problem. It is a lightweight object. On the premise of manually setting the dialect (to avoid reading the database MetaData each time), it is not a matter of creating tens of thousands of instances in a second, but usually it is not necessary.

For brevity, from version 4.0, the two classes SqlBoxContext and JSQLBOX are no longer recommended. Please use the shorter-named DbContext and DB classes.