In the previous example we use JSONObject to directly put key-value pairs to create JSON string, using the various put() methods. Instead of doing that, we can also create JSON from a Map object. We create a Map with some key-value pairs in it, and pass it as an argument when instantiating a JSONObject.
These are the steps for creating JSON from a Map:
Create a Map object using a HashMap class.
Put some key-value pairs into the map object.
Create a JSONObject and pass the map as argument to its constructor.
Print the JSONObject, we call object.toString() to get the JSON string.
Let’s try the following code snippet.
package org.kodejava.json;
import org.json.JSONObject;
import java.util.HashMap;
import java.util.Map;
public class JSONFromMap {
public static void main(String[] args) {
Map<String, String> map = new HashMap<>();
map.put("id", "1");
map.put("name", "Alice");
map.put("age", "20");
JSONObject object = new JSONObject(map);
System.out.println(object);
}
}
JSch is a pure Java implementation of SSH-2. SSH (Secure Shell) is a cryptographic network protocol for operating network services securely over an unsecured network. The following code snippet shows you how to open a connection to an ssh server.
Place your cursor where you want to add a merge field.
Click the Insert menu, Quick Parts, Fields…
In the Field names select MergeField and enter the field name and press OK.
To create merge field for image you need to prefix the field name with Image:
When finished save the document.
The Mail Merge Code Snippet
The code snippet reads the mail merge template from a file called Receipt.docx. For the image we use a duke.png. Both of these files must be placed in the /src/main/resources directory in your maven project so that the code can read it.
package org.kodejava.example.spire;
import com.spire.doc.Document;
import com.spire.doc.FileFormat;
import com.spire.doc.reporting.MergeImageFieldEventArgs;
import com.spire.doc.reporting.MergeImageFieldEventHandler;
import java.awt.Dimension;
import java.io.FileOutputStream;
import java.text.DateFormat;
import java.text.NumberFormat;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Locale;
public class MailMergeExample {
public static final Locale LOCALE = new Locale("id", "ID");
public static final DateFormat DATE_FORMAT = new SimpleDateFormat("dd-MMMM-yyyy", LOCALE);
public static final NumberFormat NUMBER_FORMAT = NumberFormat.getCurrencyInstance(LOCALE);
public static void main(String[] args) {
String[] fieldNames = new String[]{
"academicYear",
"registrationNumber",
"fullName",
"gender",
"telephone",
"address",
"paymentAmount",
"inWords",
"paymentDate",
"receivedBy",
"picture"
};
String[] fieldValues = new String[]{
"2021/2022",
"0001/REG/2021",
"Foo Bar",
"M",
"081234567890",
"Sudirman Street 100",
NUMBER_FORMAT.format(1575000),
"One Million Five Hundred Seventy Five Thousand",
DATE_FORMAT.format(new Date()),
"John Doe",
"/duke.png"
};
try {
Document document = new Document();
document.loadFromStream(MailMergeExample.class.getResourceAsStream("/Receipt.docx"), FileFormat.Auto);
document.getMailMerge().MergeImageField = new MergeImageFieldEventHandler() {
@Override
public void invoke(Object o, MergeImageFieldEventArgs field) {
field.setPictureSize(new Dimension(66, 88));
String path = field.getImageFileName();
if (path != null && !path.isEmpty()) {
try {
field.setImage(MailMergeExample.class.getResourceAsStream(path));
} catch (Exception e) {
e.printStackTrace();
}
}
}
};
document.getMailMerge().execute(fieldNames, fieldValues);
String fileName = "Receipt.pdf";
FileOutputStream fos = new FileOutputStream(fileName);
document.saveToStream(fos, FileFormat.PDF);
} catch (Exception e) {
e.printStackTrace();
}
}
}
Running the code will create a file called Receipt.pdf with the content as shown in the image below.
The following code snippet demonstrates how to use RandomStringGenerator class from the Apache Commons Text library to generate random strings. To create an instance of the generator we can use the RandomStringGenerator.Builder() class build() method. The builder class also helps us to configure the properties of the generator. Before calling the build() method we can set the properties of the builder using the following methods:
withinRange() to specifies the minimum and maximum code points allowed in the generated string.
filteredBy() to limits the characters in the generated string to those that match at least one of the predicates supplied. Some enum for the predicates: CharacterPredicates.DIGITS, CharacterPredicates.LETTERS.
selectFrom() to limits the characters in the generated string to those who match at supplied list of Character.
usingRandom() to overrides the default source of randomness.
After configuring and building the generator based the properties defined, we can generate the random strings using the generate() methods of the RandomStringGenerator. There are two methods available:
generate(int length) generates a random string, containing the specified number of code points.
generate(int minLengthInclusive, int maxLengthInclusive) generates a random string, containing between the minimum (inclusive) and the maximum (inclusive) number of code points.
And here is your code snippet:
package org.kodejava.commons.text;
import org.apache.commons.text.CharacterPredicates;
import org.apache.commons.text.RandomStringGenerator;
public class RandomStringDemo {
public static void main(String[] args) {
RandomStringGenerator generator = new RandomStringGenerator.Builder()
.withinRange('0', 'z')
.filteredBy(CharacterPredicates.DIGITS, CharacterPredicates.LETTERS)
.build();
for (int i = 0; i < 10; i++) {
System.out.println(generator.generate(10, 20));
}
}
}
Below are examples of generated random alphanumeric strings:
By default, when we use the Lombok’s @Getter and @Setter annotations the getters and setters will be created with public access modifier. We can however change the access modifier by setting the AccessLevel of the @Getter and @Setter annotations. The available choices for the access level are AccessLevel.PUBLIC, AccessLevel.PROTECTED, AccessLevel.PACKAGE, AccessLevel.PRIVATE. These enum values correspond to Java’s access modifier. While the AccessLevel.NONE will disable the getter and setter method generation.
package org.kodejava.lombok.support;
import lombok.AccessLevel;
import lombok.Getter;
import lombok.Setter;
@Getter
@Setter
public class Person {
@Setter(AccessLevel.PROTECTED)
private String firstName;
private String lastName;
private String gender;
@Getter(AccessLevel.PRIVATE)
private int age;
}
How we use the Person class show in the snippet below:
package org.kodejava.lombok;
import org.kodejava.lombok.support.Person;
public class PersonDemo {
public static void main(String[] args) {
Person person = new Person();
person.setLastName("Bar");
person.setGender("M");
person.setAge(20);
System.out.println(person.getFirstName());
System.out.println(person.getLastName());
System.out.println(person.getGender());
}
}
If we try to see the generated class of the Person class we can run the following command to disassemble the class.
javap -p -cp . org.kodejava.lombok.support.Person
And we got the following output of the javap command. As we can see that the setFirstName() method have a protected access modifier and the getAge() method have a private access modifier. The other mutator and accessor method all set to public access modifier.
public class org.kodejava.lombok.support.Person {
private java.lang.String firstName;
private java.lang.String lastName;
private java.lang.String gender;
private int age;
public org.kodejava.lombok.support.Person();
public java.lang.String getFirstName();
public java.lang.String getLastName();
public java.lang.String getGender();
public void setLastName(java.lang.String);
public void setGender(java.lang.String);
public void setAge(int);
protected void setFirstName(java.lang.String);
private int getAge();
}
The following code snippet show you how to use Project Lombok‘s @Getter and @Setter annotations to generate getters and setters method in your POJO (plain old java objects) classes. Using these annotations remove the need to manually implements the mutator and accessor methods. Although most IDE allows you to generate these methods, using Lombok makes your classes look cleaner, especially when you have a long list of fields.
Here is a simple User class with a handful fields. We will use the @Getter and @Setter annotations on the class level. This will generate the getters and setters method for any non-static fields in the class.
package org.kodejava.lombok.support;
import lombok.Getter;
import lombok.Setter;
import java.time.LocalDate;
@Getter
@Setter
public class User {
private Long id;
private String username;
private String password;
private LocalDate lastLogin;
private boolean active;
}
Each fields in the class will have its corresponding getter and setter. For example the username field will have the getUsername() and setUsername() method. If the field type is boolean such as active it will generate the method setActive() and isActive() method.
Because the accessor and mutator already handled by Lombok, we can use the User class as if we manually implement the getters and setters method.
package org.kodejava.lombok;
import org.kodejava.lombok.support.User;
import java.time.LocalDate;
public class UserDemo {
public static void main(String[] args) {
User user = new User();
user.setId(1L);
user.setUsername("foo");
user.setPassword("secret");
user.setLastLogin(LocalDate.now());
user.setActive(true);
System.out.println(user.getId());
System.out.println(user.getUsername());
System.out.println(user.getPassword());
System.out.println(user.getLastLogin());
System.out.println(user.isActive());
}
}
If for some reasons you want to disable the getter and setter on specific field, or you want the change the access level, you can use the AccessLevel enums value for the @Getter and @Setter annotations. For example in the code snippet below the username will have no getter and setter while the lastLogin getter and setter will have protected access modifier. The AccessLevel enums includes PUBLIC, MODULE, PROTECTED, PACKAGE, PRIVATE and NONE.
package org.kodejava.lombok.support;
import lombok.AccessLevel;
import lombok.Getter;
import lombok.Setter;
import java.time.LocalDate;
@Getter
@Setter
public class User {
private Long id;
@Getter(AccessLevel.NONE)
@Setter(AccessLevel.NONE)
private String username;
private String password;
@Getter(AccessLevel.PROTECTED)
@Setter(AccessLevel.PROTECTED)
private LocalDate lastLogin;
private boolean active;
}
The following code snippet show you how to create JSON string using JSON-Java library. Create an instance of JSONObject and use the put() method to create a key-value pair for the JSON string. The JSONArray object can be used to create an array of list of values to the JSON string, we also use the put() method to add value to the list.
The JSONObject.toString() method accept parameter called indentFactor, this set the indentation level of the generated string, which also make the JSON string generated easier to read and look prettier.
package org.kodejava.json;
import org.json.JSONArray;
import org.json.JSONObject;
public class WriteJSONString {
public static void main(String[] args) {
JSONObject object = new JSONObject();
object.put("id", 1L);
object.put("name", "Alice");
object.put("age", 20);
JSONArray courses = new JSONArray();
courses.put("Engineering");
courses.put("Finance");
courses.put("Chemistry");
object.put("courses", courses);
String jsonString = object.toString(2);
System.out.println(jsonString);
}
}
In this example we are going to use the JSON-Java (org.json) library to read or parse JSON file. First we start by getting the InputStream of the JSON file to be read using getResourceAsStream() method. Next we construct a JSONTokener from the input stream and create an instance of JSONObject to read the JSON entries.
We can use method like getString(), getInt(), getLong(), etc. to read a key-value from the JSON file. The getJSONArray() method allow us to read a list of values returned in JSONArray object, which can be iterated to get each values represented by the key. Let’s see the detail code snippet below.
The following example demonstrates how to pretty print the JSON string produces by Jackson library. To produce well formatted JSON string we create the ObjectMapper instance and enable the SerializationFeature.INDENT_OUTPUT feature. To enable this feature we need to call the enable() method of the ObjectMapper and provide the feature to be enabled.
ObjectMapper mapper = new ObjectMapper().enable(SerializationFeature.INDENT_OUTPUT);
String json = mapper.writeValueAsString(recording);
System.out.println(json);
On the second example below we format unformatted JSON string. To do this we use the ObjectMapper‘s readValue(String, Class<T>) method which accept the JSON string and Object.class as the value type. The readValue() method return an Object. To format the JSON object we call mapper.writerWithDefaultPrettyPrinter().writeValueAsString(Object). This will produce a pretty formatted JSON.
Here are the structure of Recording, Artist and Label classes.
package org.kodejava.jackson.support;
import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
import com.fasterxml.jackson.databind.annotation.JsonSerialize;
import org.kodejava.jackson.LocalDateDeserializer;
import org.kodejava.jackson.LocalDateSerializer;
import java.time.LocalDate;
public class Recording {
private Long id;
private String title;
@JsonDeserialize(using = LocalDateDeserializer.class)
@JsonSerialize(using = LocalDateSerializer.class)
private LocalDate releaseDate;
private Artist artist;
private Label label;
// Getters and Setters
}
package org.kodejava.jackson.support;
public class Artist {
private Long id;
private String name;
public Artist() {
}
public Artist(Long id, String name) {
this.id = id;
this.name = name;
}
// Getters and Setters
}
package org.kodejava.jackson.support;
public class Label {
private Long id;
private String title;
public Label(Long id, String title) {
this.id = id;
this.title = title;
}
// Getters and Setters
}
We have a Recording class which has a Java 8 java.time.LocalDate property. We need to deserialize and serialize this property from and to JSON string. To do this we can use the @JsonDeserialize and @JsonSerialize annotations to annotate the LocalDate property of the Recording class.
To use the annotation we need to create a class to deserialize and serialize the value. To create a deserializer class we create a class that extends StdDeserializer. The serializer class extends the StdSerializer class. Below is the definition of the LocalDateSerializer and LocalDateDeserializer class.
package org.kodejava.jackson;
import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.databind.SerializerProvider;
import com.fasterxml.jackson.databind.ser.std.StdSerializer;
import java.io.IOException;
import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
public class LocalDateSerializer extends StdSerializer<LocalDate> {
public LocalDateSerializer() {
super(LocalDate.class);
}
@Override
public void serialize(LocalDate value, JsonGenerator generator, SerializerProvider provider) throws IOException {
generator.writeString(value.format(DateTimeFormatter.ISO_LOCAL_DATE));
}
}
