Piero Steffano Del Aguila Macher

Quarkus goes Reactive☢

2021-03-03T06:38:00.002-08:00

In this tutorial I will explain how to create a quarkus based java application that will use reactive datasource to connect to a postgres database and be able to perform crud operations via rest endpoint. To make it more real this application will also be published into kubernetes cluster and will use configmap to store datasource configuration. To lern more about benefits of reactive data sources vs. jdbc regular data sources you can go to following link https://cutt.ly/1l260tK.

Step 1: Configure Project

In order to start we use and artifact to generate our base project by using the following command:

mvn io.quarkus:quarkus-maven-plugin:1.6.1.Final:create \ -DprojectGroupId=com.pierosteffano \ -DprojectArtifactId=quarkus-reactive-demo \
-DclassName="com.pierosteffano.EmployeeResource" \ -Dpath="/employees" \ -Dextensions="quarkus-resteasy, quarkus-junit5, rest-assured, quarkus-resteasy-jsonb, quarkus-jdbc-postgresql, quarkus-hibernate-orm-rest-data-panache, quarkus-hibernate-orm-panache, quarkus-smallrye-openapi, quarkus-agroal, quarkus-kubernetes, quarkus-kubernetes-config, quarkus-container-image-docker, quarkus-reactive-pg-client, quarkus-resteasy-mutiny"

This will create a maven base project containing all the dependencies that will be used in this tutorial.

Step 2: Add pojo class

In package com.pierosteffano create a class file named Employee. import io.smallrye.mutiny.Multi;
import io.vertx.mutiny.pgclient.PgPool;
import io.vertx.mutiny.sqlclient.Row;

public class Employee {

private Long id;
private String name;
private String lastname;

On above I'm showing the imports you will need to add and the properties of the Pojo class that will be mapped to table columns. Don't forget to generate mutators and accessors...
After that we need to add the following methods that will be used to retrieve data from employee table.

private static Employee from(Row row) {
   return new Employee(row.getLong("id"), row.getString("name"),row.getString("lastname"));
}
public static Multi<Employee> findAll(PgPool client) {
   return client.query("SELECT id, name,lastname FROM employees ORDER BY name ASC").execute()
           .onItem().transformToMulti(set -> Multi.createFrom().iterable(set))
           .onItem().transform(Employee::from);
}

Step 3: Resource class

Having done that you will need to create another class that will act as entrypoint of the application.

import io.smallrye.mutiny.Multi;
import org.eclipse.microprofile.config.inject.ConfigProperty;
import javax.annotation.PostConstruct;
import javax.inject.Inject;
import javax.ws.rs.Consumes;
import javax.ws.rs.GET;
import javax.ws.rs.Path;
import javax.ws.rs.Produces;
import javax.ws.rs.core.MediaType;

@Path("employees")
@Produces(MediaType.APPLICATION_JSON)
@Consumes(MediaType.APPLICATION_JSON)
public class EmployeeResource {

In this case I named the class as EmployeeResource but you can choose another name.
The important things you need to follow is to include all the imports mentioned on above example, later on you will need to add following fields:

@Inject
io.vertx.mutiny.pgclient.PgPool client;
@Inject
@ConfigProperty(name = "myapp.schema.create", defaultValue = "true")
boolean schemaCreate;

Then you add the following methods in order to create table and populate it:

@PostConstruct
void config() {
   if (schemaCreate) {
       initdb();
   }
}

private void initdb() {
   client.query("DROP TABLE IF EXISTS employees").execute()
             .flatMap(r -> client.query("CREATE TABLE employees (id SERIAL PRIMARY KEY, name TEXT NOT NULL,lastname TEXT NOT NULL)").execute())
           .flatMap(r -> client.query("INSERT INTO employees (name,lastname) VALUES ('John','Doe')").execute())
           .flatMap(r -> client.query("INSERT INTO employees (name,lastname) VALUES ('Jane','Doe')").execute())
           .flatMap(r -> client.query("INSERT INTO employees (name,lastname) VALUES ('Hamilton','Lincoln')").execute())
           .await().indefinitely();
}

Finnally as part of demostration we will add a GET operation in order to fetch employee table information:

@GET
public Multi<Employee> get() {
   return Employee.findAll(client);
}

In order to test you can use following docker sentence to create a postgress db instance:

docker run --ulimit memlock=-1:-1 -it --rm=true --memory-swappiness=0 --name quarkus_test -e POSTGRES_USER=quarkus -e POSTGRES_PASSWORD=quarkus -e POSTGRES_DB=quarkusdb -p 5432:5432 postgres:10.5

After container is up and running you can test the application by using following command:

Windows: mvn compile quarkus:dev
Linux: ./mvn compile quarkus:dev

When application is Up you can hit the following url in your browser: http://localhost:8080/employees in order to list Employee table contents.

Furter steps:

To be more real life example here we will set hostname of database connection as config map entry. In order to do that first we need to create a yml file with the sintax and the use kubectl apply command like the following:

apiVersion: v1 data:
database: "172.17.0.2"
kind: ConfigMap
metadata:
name: quarkus-reactive-demo-config

To use this configmap on our application we add the following on application.properties:

%prod.kubernetes.env-vars[0].name=DB_HOST
%prod.kubernetes.env-vars[0].value=database
%prod.kubernetes.env-vars[0].configmap=quarkus-reactive-demo-config

Notice %prod prefix. This means that property will be used only on prod profile defined on your pom.xml
You can create a profile by adding following on your pom.xml file inside <profiles> tag:

<profile>
   <id>prod</id>
   <activation>
       <property>
           <name>environment</name>
           <value>prod</value>
       </property>
   </activation>
</profile>

After that you will be able to use configMap variable DB_HOST inside you application.properties but name will have some differences: Name will be lowercase and dash character need to be replaced as dot. You can see the following as an example:

quarkus.datasource.reactive.url=postgresql://${db.host}:5432/quarkusdb

In order to package docker container in quarkus you have 3 options: fast-jar, jvm or native each of them has pro and cons(for more information on quarkus packae types you can go to https://quarkus.io/guides/maven-tooling).
You can get how to package on the three different ways by having a look on src/main/docker directory.
In this tutorial I've chosen native profile and also added my own prod profile so app can make use of configmap values created before.
To package the jar I used following sentence:

mvn package -Pnative,prod -Dquarkus.native.container-build=true

After jar is generated we can use following command to create docker image:

docker build -f src/main/docker/Dockerfile.native -t pierosteffano/quarkus-reactive-demo:1.0-SNAPSHOT .

I updated tag of the image in order to make it work with kubertnetes extension that is used after.
After we do maven package ther will be a kubernetes yml and json files that can be used to create pods based on following properies defined on application.properties.

quarkus.container-image.group=pierosteffano
%prod.quarkus.kubernetes-config.enabled=true
%prod.quarkus.kubernetes.replicas=1
%prod.quarkus.kubernetes.readiness-probe.initial-delay=20s
%prod.quarkus.kubernetes.readiness-probe.period=45s
%prod.quarkus.kubernetes.deployment-target=kubernetes
%prod.quarkus.container-image.tag=1.0-SNAPSHOT

In order to create kubernetes pods / services / deployments we use the following:

kubectl apply -f target/kubernetes/kubernetes.json

After that if we need to test in localhost we can create a port forward using the following command:

kubectl port-forward service/quarkus-reactive-demo 8080:8080

Finally we can test by using the following url:

http://localhost:8080/employees

wcs query to fetch shipping cost by store

2021-02-04T04:17:00.000-08:00

In websphere commerce 7 model you can use the folloging query to fetch the shipping cost of catalog entries. This query could also be useful for newer versions.

select cr.calrange_id,cc.calcode_id, c.partnumber,j.code,j.description,value from catentry c
left outer join CATENCALCD cd on c.catentry_id=cd.catentry_id
left outer join calcode cc on cd.calcode_id=cc.calcode_id
left outer join calrule r on cc.calcode_id=r.calcode_id
left outer join CRULESCALE s on r.calrule_id=s.calrule_id
left outer join CALRANGE cr on s.calscale_id=cr.calscale_id
left outer join CALRLOOKUP cl on cr.CALRANGE_id=cl.CALRANGE_id
left outer join SHPJCRULE sr on sr.calrule_id=r.calrule_id
left outer join JURSTGROUP jg on jg.jurstgroup_id=sr.jurstgroup_id
left outer join JURSTGPREL jgr on jgr.jurstgroup_id=jg.jurstgroup_id
left outer join JURST j on j.jurst_id=jgr.jurst_id
where (partnumber like 'partnumber% )
and catenttype_id in ('ItemBean','PackageBean')
and cc.storeent_id=storeid

and cr.markfordelete=0

Replacing text and remove duplicates by first column

2021-02-04T04:14:00.002-08:00

When working with plain text files like csv's you can use the following sentence to remove duplicates. It is a combination of sed and awk commands

sed -E 's/([-]{1})([0-9]+)([-]{1})/-WER-/g' file.csv | awk -F- '!seen[$1]++' > outputfile.csv

Removing duplicates with awk

2018-04-13T08:34:00.003-07:00

To remove duplicates in linux you can use awk command as follows:

awk -F- '!seen[$1]++' file.txt > output.txt

where:

-F is paraeter to deternime separator used to define columns and in ths case the dash 8-) is the sparator used

'!seen[$1]++' is the expression used for the line in order to be printed

> is the instruction to send command output o a file

Disable scrolling temporary

2018-04-13T05:41:00.001-07:00

Following example is with jquery but you can doit with plain javascript aswell.

To disable a scroll in a webpage:

$('body').css('height', window.innerHeight+'px');
$('body').css('overflow', 'hidden');

To enable it again:

$('body').css('height', 'inherit');
$('body').css('overflow', 'none');

Java execution using ant

2018-04-12T06:25:00.001-07:00

To execute a java program create a build xml like:

then execute it by using: ant -buildfile [whathevernameyouwant].xml

Register new WCS store view by using database

2018-04-12T05:58:00.001-07:00

To register a new view by using SQL queries:

insert into acaction (acaction_id, action) values ((select counter from keys where tablename='acaction'), 'NewView');

insert into acactactgp (ACACTGRP_ID,ACACTION_ID) values
((SELECT ACACTGRP_ID FROM ACACTGRP WHERE GROUPNAME = 'AllSiteUsersViews'
and member_id in (select orgentity_id from orgentity where orgentityname='Root Organization')
),
(select acaction_id from acaction where action='NewView'));

UPDATE KEYS SET COUNTER = COUNTER+1 WHERE TABLENAME = 'acaction';
commit

Configuring web application with gwt+spring+hibernate (continued)

2012-08-14T09:35:00.004-07:00

Last Time we learned how to configure a hibernate+ spring+ GWT application.
Now we will continue explaining how I built this application.
First, we'll start with the Beans.
For this example we will define one bean called Regions and an interface called Bean.
Region will be the pojo class that contains the mapping for HR schema regions table

The @Entity annotation is used to mark this class as an Entity bean. To use this annotation the class must have at least a package scope no-argument constructor.

The @Table annotation is used to specify the table to persist the data. The name attribute refers to the table name. If @Table annotation is not specified then Hibernate will by default use the class name as the table name.

The @Id annotation is used to specify the identifier property of the entity bean. The placement of the@Id annotation determines the default access strategy that Hibernate will use for the mapping. If the @Id annotation is placed over the field, then field access will be used. Instead if it placed over the getter method of that field, then property access will be used. Here we use property access.

The @Column annotation is used to specify the details of the column to which a field or property will be mapped. Here the regionName property is mapped to REGION_NAME column in the REGIONS table. If we don't use the property name of this annotation then hibernate will take the property name as column name.

The Bean interface extends Serializable and Comparable and will be implemented by our Pojo's

The comparable interface is for sorting purposes but is out of the scope of this example.

Now well proceed to write the DAO.

First will tell spring that this class will by a data accesor by using @Repository annotation. The name param is optional, if you don define it then spring will put a default one.

The @Transactional annotation is used to make all the methods to be within a transaction. (the default is read-only)

Next step, the method to retrieve regions:

I used criteria instead of HQL and also implemented the pagination on "DB side".
I also use a "Set" implementation because it doesn't allow repeated values. (this is necessary in case of @OneToMany relationships).

There are some interfaces that I've created but I think you could infer them.

Now, with the DAO complete, I'll proceed to explain the Spring Service layer
The business service layer for this example is too simple I will just mention it because of a couple of annotations

To define a business service in spring It is needed to add the @Service annotation to the Class definition as you can see on the image above. The name attribute is optional.
The @Autowired annotations tells spring to automatically make an instance of the annotated Field. This instantation is made when the spring context loads.
In this service class we call the DAO to read/write data, you could also put some business rules if you need to.
Here, I've defined the following method to retrieve the regions:

Finally I will explain what you need to write to show the regions list on screen through GWT
First, you need to have an Entrypoint class as the one below:

After we have this class we proceed to develop onModuleLoad to start the process of showing the regions list

In this method we define new object and map objects that already exists on our mapped html.
*Note: You have to tell GWT which module to bind by declaring it on your html as follows:

The findRegions method is in charge of calling an AsynchService to get the Regions List.

In the method above the declare a new Table that will be inserted within the table container that is a Paragraph object (
)
Once you finished writing this you will get a lot of error and it because we need to define the method en regionService. Will will do that now.
We need to define 2 interfaces one for Synchronous communication and the other one for asynchronous communication (Ajax).
We will start with synch interface: RegionsClientService

The @RemoteServiceRelativePath enables the calling of this service by using a url string or as Javadoc says: "Associates a RemoteService with a relative path. This annotation will cause the client-side proxy to automatically invoke the ServiceDefTarget.setServiceEntryPoint(String) method withGWT.getModuleBaseURL() + value() as its argument. Subsequent calls to ServiceDefTarget.setServiceEntryPoint(String) will override this default path."

Once this interface you need to proceed defining the asynch interface RegionClientServiceAsync as follows:

Notice that the method signature is different from the other interface this is because GWT needs to wrap the method argument inside an AsyncCallBack to work with the result in an asynchronous way.
Finally comes the implementation RegionClientServiceImpl:

As you can notice, this class is a Servlet. That's why you hate to define it on web.xml:

*Note: The trailing url pattern must match the string defined on @RemoteServiceRelativePath

Now to end of this tut I will show how to run this project:

Right click on the desired webpage and then select run as - Web Application option from the context menu.
This will trigger the starting of Jetty embedded server and will show a link to start the page:

After you double click this link, the system will raise an explorer window with our page:

Now we have a fully functional hibernate+spring+gwt application that you can use as a template for any web app you want.

Configuring web application with gwt+spring+hibernate

2012-08-09T12:40:00.001-07:00

Building a web application using hibernate, spring and gwt.

This time we will show how to create and cofigure an application that will use hibernate , spring and gwt.
I will use HR sample database that comes with OracleXE.
First , you have to create a GWT project (you can follow the steps for that on https://developers.google.com/web-toolkit/)

After you have the project created you need to create a tree of packages like that:

Open HumanResources.gwt.xml and add the following line :

By doing that you tell gwt to include model package and all dependent packages into gwt compilation

Now we can start configuring spring and hibernate.

to configure spring first you have to add the following lines on web.xml

This will allow spring context to start doing its business.
The you will have to create a field called "app-config.xml" in which you will define the settings for spring and hibernate.
Over this app-config file first configure the properties as follows

You will have to create another file called configuration.properties in which you will define the values of the properties that you will use on you xml (this will also apply for included xmls)

Next you need to configure the component scan as follows

The lines above will tell spring to scan the annotations defined on classes of package com.model.services and com.hr.model.daos

The last step for this file is to include the xml for configuring hibernate:

By doing that you will tell spring to read also the contents of db-config.xml.

Now is time to configure db-config.xml, this file contains all the configuration that hibernate will use:

Remember the file called configuration.properties? Well, here is where we will use the properties defined on it.
After defining the DS we proceed to set-up hibernate session factory

Here you define the packages to scan. These will tell hibernate where to look for annotated classes in this example hibernate will look on "com.hr.model.beans".
You will also use the values defined on configuration.properties to tell hibernate which dialect to use. The database of the example is oracle in my case I use "org.hibernate.dialect.Oracle10gDialect"
Finally we will define the TransaciontManager and add the sessionFactory we've created and also tell spring that you will define the transactional behaviour by using annotations:

That's it. We finished configuring the project, now we can start coding.

On the next post I will explain step for step the coding for this tutorial.

Volatile keyword in JAVA

2012-07-30T15:23:00.001-07:00

I've found an interesting and easy to understand explanation about volatile keyword, it came with an example but it was wrong so I've corrected it.
A volatile variable does not have a copy maintained in the local memory of the thread (on the stack). All changes to the volatile variable (caused by multiple threads) are flushed out to the heap memory (visible from all threads). Hence volatile variable values remain consistent for all threads.

On the other hand, for other instance variables, each java thread maintains a local copy on the stack. Multiple threads may modify this local copy of the instance variable and hence inconsistent values may be visible for multiple threads.

For preventing this condition, we synchronize. During synchronization, a lock is first taken on the object monitor. Then the thread reads the state from the main memory and flushes its internal state. Subsequently, the synchronized code block/method code is executed. Once the execution completes, all the changes to the variables of that thread are flushed out to the main memory. Then the object monitor lock is released.

So, as we can see, volatile is a specialized case of synchronization. The only exceptions are, that it operates on a single field and no locks on the object monitor are required (as it operates on the heap memory and not the thread local stack memory).
If you are working with the multi-threaded programming, the volatile keyword will be more useful. When multiple threads using the same variable, each thread will have its own copy of the local cache for that variable. So, when it's updating the value, it is actually updated in the local cache not in the main variable memory. The other thread which is using the same variable doesn't know anything about the values changed by the another thread. To avoid this problem, if you declare a variable as volatile, then it will not be stored in the local cache. Whenever thread are updating the values, it is updated to the main memory. So, other threads can access the updated value.

class ExampleThread extends Thread {

private volatile int testValue;

public ExampleThread(String str) {

super(str);

}

public void run() {

for (int i = 0; i < 3; i++) {

try {

System.out.println(Thread.currentThread().getName() + " : " + i);

if (Thread.currentThread().getName().equalsIgnoreCase("T1")) {

System.out.println("Test Value T1: " + testValue);

testValue = 10;

}

if (Thread.currentThread().getName().equalsIgnoreCase("T2")) {

System.out.println("Test Value T2: " + testValue);

testValue = 20;

}

Thread.sleep(1000);

} catch (InterruptedException exception) {

exception.printStackTrace();

}

public class VolatileExample {

public static void main(String args[]) {

ExampleThread exampleThread = new ExampleThread("Thread 1 ");

Thread t1 = new Thread(exampleThread, "T1");

Thread t2 = new Thread(exampleThread, "T2");

t1.start();

t2.start();

}

2012-07-11T08:16:00.005-07:00

Calling a rest service with spring rest + json jackson Presenting to you step by step a tutorial about the use of some apis that leverage the logic for calling to a rest service and also the json parting and marshalling process
First Step Importing required libs:

You will need to import spring for droid there are the files:
spring-android-auth-1.0.0.M4.jar
spring-android-core-1.0.0.M4.jar
spring-android-rest-template-1.0.0.M4.jar

You will need to import jackson lib there is the file:
jackson-all-1.9.4.jar

Second Step : Declaring variables
You will need these three variables to do the trick. I will recomend to declare them as fields and instantiate them later on class constructor.

RestTemplate restTemplate = new RestTemplate();
ObjectMapper objectMapper = new ObjectMapper();
JsonFactory jsonFactory = new JsonFactory();

Third step: Calling rest service:

Just call this method of rest template and the api will call the service and will encapsulate all the stream stuff and present you the response as a string file in this example.

String url = "yourjsonrestserviceurl");
String result = restTemplate.getForObject(url, String.class);

Fourth Step: Creating json parser and marshalling the json result into an object

JsonParser jp = jsonFactory.createJsonParser(result);
MappingIterator list = objectMapper.readValues(jp, YourBean[].class);

Finally Some recomendations:
You should get some errors depending of the format of your json. Here are some workarounds:

to map a field with different names:
Add anotation @JsonProperty("yourJSONfield") to the POJO field you want to map.
To ignore a POJO field on marshalling process: @JsonIgnore

Jaxcent

2008-12-29T07:28:00.000-08:00

Hace un tiempo, buscando frameworks para java , me tope con Jaxcent.
Jaxcent es un framework gratis, para la programacion en ajax. Lo interesante de este framework es que no necesitas escribir codigo javascript, solo programas en java. Se que existen frameworks como el google toolkit y javafx que tienen esta capacidad, pero Jaxcent me parecio el mas rapido de configurar y utilizar.
Dejo el enlace para que lo bajen y me brinden sus opiniones.

www.jaxcent.com

Tipo Enum en java 5

2008-11-17T07:06:00.000-08:00

Encontré un articulo interesante que habla de los tipos enum en java, y bueno aqui está:

En Java 5 se permite que una variable tenga solo un valor dentro de un conjunto de valores predefinidos, en otras palabras, valores dentro de una lista enumerada. Los tipos enumerados sirven para restringir la selección de valores a algunos previamente definidos, p. ej., si tenemos una aplicación para la venta de café en vasos de diferentes tamaños pero no queremos que los tamaños sean diferentes a CHICO, MEDIANO y GRANDE, podemos crear un tipo enumerado para delimitar dicha selección:

enum TamanoDeCafe{CHICO,MEDIANO,GRANDE};

Posteriormente, al elegir un tamaño de café podemos hacerlo de la siguiente manera:

TamanoDeCafe tdc = TamanoDeCafe.MEDIANO;

No es necesario que las constantes dentro de los enums estén en mayúsculas pero en las convenciones de código de Sun se pide hacerlo de esta manera. Se debe tomar en cuenta que un tipo enumerado puede ser declarado dentro o fuera de una clase, pero NO dentro de un método. P. ej.:

enum instrumentos{
GUITARRA, TROMPETA, BATERIA, BAJO
};

public class Enumerados {

public Enumerados() {
}

public static void main (String... args){
instrumentos in = instrumentos.BATERIA;
System.out.println(in);
EnumDentroClase edc = new EnumDentroClase();
edc.tamano = EnumDentroClase.TamanoDeCafe.CHICO;
System.out.println(edc.tamano);
}

}

class EnumDentroClase{

enum TamanoDeCafe {GRANDE,MEDIANO,CHICO};

TamanoDeCafe tamano;
}

Nota: el punto y coma (;) al final de la declaración del tipo enumerado es opcional.

Al ejecutar el código anterior, obtenemos:

BATERIA
CHICO

Los tipos enumerados no son enteros o cadenas, cada uno es simplemente una instancia del tipo enumerado del que es declarado. Se puede pensar como una especie (no exactamente) de arreglo de variables estáticas finales. Además de constantes dentro de un tipo enumerado, existen algunas otras cosas que puede tener.

Declarar constructores, métodos y variables dentro de un tipo enumerado::

Debido a que los tipos enumerados son como una clase de tipo especial en Java, hay muchas cosas que se pueden realizar dentro de un enum, además de declarar constantes, un tipo enumerado puede contener constructores, métodos y variables.

Tomando nuestro ejemplo del tamaño de café, podemos pensar en escenario donde además de saber el tamaño del café necesitemos la cantidad en onzas de cada tamaño, esto podemos hacerlo de la siguiente manera:

enum TamanoCafe{

CHICO(5), MEDIANO(8), GRANDE(10);

private int onzas;

TamanoCafe(int onzas){
this.onzas = onzas;
}

public int getOnzas(){
return this.onzas;
}

}

public class Cafe {
TamanoCafe tc;
public Cafe() {
}

public static void main(String... args){
Cafe c1 = new Cafe();
Cafe c2 = new Cafe();
c1.tc = TamanoCafe.GRANDE;
c2.tc = TamanoCafe.CHICO;

System.out.println("Tamaño de café 1(c1): "+c1.tc);
System.out.println("Tamaño de café 2(c2): "+c2.tc);

System.out.println("Onzas 1(c1): "+c1.tc.getOnzas());
System.out.println("Onzas 2(c2): "+c2.tc.getOnzas());
}

}

Al ejecutar el código anterior obtendremos lo siguiente:

Tamaño de café 1(c1): GRANDE
Tamaño de café 2(c2): CHICO
Onzas 1(c1): 10
Onzas 2(c2): 5

Algunos puntos importantes sobre los constructores de los tipos enumerados:

+ No se puede invocar al constructor directamente, este se invoca una vez que se crea el tipo enumerado y es definido por los argumentos utilizados para crearlo.

+ Se puede definir más de un argumento en un constructor de un tipo enumerado, asimismo, se puede definir más de un constructor para un tipo enumerado siempre y cuando este tenga argumentos diferentes(sobrecargar el constructor).

Diferencias del Metodo equals() y ==

2008-11-14T09:14:00.001-08:00

Por ejemplo, el tipo de datos int, en Java, es un tipo de dato de los llamados primitivos (más o menos como c++), con lo cuál puedes utilizar los operadores lógicos y aritméticos de la forma habitual. En tu caso puedes utilizar el operador == de la manera normal. Sin embargo, Integer, no es un tipo de dato primitivo. Es una clase!!. Entoces cuando tú tienes un objeto del tipo Integer NO estás manejando su valor, sino un puntero a tu objeto Integer. Porque en Java todo son punteros (menos los tipos de datos primitivos). Así que cuando utilizas el operador == no estás comparando el valor de los integer, sino los punteros (las direcciones que apuntan al objeto). De modo que para objetos estás obligado a utilizar el método equals().