Install java on macOS with allowing version switching

Installing with Homebrew

-- Updating brew:
brew update

-- Adding the casks tap:
brew tap homebrew/cask-versions

-- Adding AdoptOpenJDK (https://adoptopenjdk.net/ and https://github.com/AdoptOpenJDK/homebrew-openjdk):
brew tap adoptopenjdk/openjdk

-- Looking for java versions:
brew search java

-- Looking for AdoptOpenJDK versions:
brew search jdk

-- Checking the details on the java version that will be installed:
brew cask info java

-- Checking the details on the AdoptOpenJDK version that will be installed:
brew cask info jdk

-- Installing current version java:
brew cask install java

-- Installing specific version of AdoptOpenJDK:
brew install --cask adoptopenjdk12

Where is my java?

/usr/libexec/java_home -V

Switching java version using .bash_profile:

export JAVA_8_HOME=$(/usr/libexec/java_home -v1.8)
export JAVA_9_HOME=$(/usr/libexec/java_home -v9)
export JAVA_10_HOME=$(/usr/libexec/java_home -v10)
export JAVA_11_HOME=$(/usr/libexec/java_home -v11)
export JAVA_12_HOME=$(/usr/libexec/java_home -v12)
export JAVA_13_HOME=$(/usr/libexec/java_home -v13)

alias java8='export JAVA_HOME=$JAVA_8_HOME'
alias java9='export JAVA_HOME=$JAVA_9_HOME'
alias java10='export JAVA_HOME=$JAVA_10_HOME'
alias java11='export JAVA_HOME=$JAVA_11_HOME'
alias java12='export JAVA_HOME=$JAVA_12_HOME'
alias java13='export JAVA_HOME=$JAVA_13_HOME'

# default to Java 13
java13

source: https://stackoverflow.com/questions/52524112/how-do-i-install-java-on-mac-osx-allowing-version-switching

Installing Java17

source: https://java.tutorials24x7.com/blog/how-to-install-openjdk-17-on-mac

Java - Try With Resources

https://www.baeldung.com/java-try-with-resources

Rounding BigDecimal into scale 2 in WebService

BigDecimalConverter class:

final class BigDecimalConverter {
    private final static Logger logger = LoggerFactory.getLogger(BigDecimalConverter.class);

    private static final int SCALE = 2;

    static String convertToString(BigDecimal bigDecimal) {
        if (bigDecimal == null) {
            return null;
        }

        logger.info("Rounding bigDecimal {} into scale {}", bigDecimal, SCALE);
        return bigDecimal.setScale(SCALE, RoundingMode.HALF_UP).toString();
    }
}

BigDecimalXmlAdapter class:

public class BigDecimalXmlAdapter extends XmlAdapter {
    private final static Logger logger = LoggerFactory.getLogger(BigDecimalXmlAdapter.class);

    @Override
    public BigDecimal unmarshal(String s) {
        logger.info("Unmarshal String: {}", s);

        try {
            return new BigDecimal(s);
        } catch (NumberFormatException e) {
            return null;
        }
    }

    @Override
    public String marshal(BigDecimal bigDecimal) {
        logger.info("Marshal BigDecimal {}", bigDecimal);

        return BigDecimalConverter.convertToString(bigDecimal);
    }
}

package-info.java file:

@javax.xml.bind.annotation.XmlSchema(namespace = "http://app.host.pl/api/types", elementFormDefault = javax.xml.bind.annotation.XmlNsForm.QUALIFIED)
@javax.xml.bind.annotation.adapters.XmlJavaTypeAdapters({
        @javax.xml.bind.annotation.adapters.XmlJavaTypeAdapter(value = pl.marceen.soap.control.BigDecimalXmlAdapter.class, type = java.math.BigDecimal.class)
})
package pl.host.app.api.types;

Testing for SimpleDateFormat thread safety

https://www.dontpanicblog.co.uk/2013/12/08/testing-for-simpledateformat-thread-safety/

How to make mock to void methods with Mockito

Call Real Method

Mock not void method:

Mockito.when(jsonResponseValidator.validate(any(DefaultResponse.class))).thenCallRealMethod()

Mock void method:

Mockito.doCallRealMethod().when(jsonResponseValidator).validate(any(DefaultResponse.class));

You can use any of the doReturn(), doThrow(), doAnswer(),doNothing(), doCallRealMethod() family of methods.

Do Throw

Mock void method with doThrow():

...

@Mock
privare TransferSender transferSender;

...
Transfer transfer = new Transfer();
Mockito.doThrow(new MyException("kabooom!").when(transferSender).send(transfer);

source: Mockito API

JavaEE - wyświetlenie całego URI za pomocą UriInfo

UriInfo (za pomocą którego jest możliwe wyciągnięcie całego URI) można wstrzyknąć za pomocą adnotacji @Context jako pole klasy:

package pl.marceen.test.boundary;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import javax.ejb.Stateless;
import javax.ws.rs.GET;
import javax.ws.rs.Path;
import javax.ws.rs.core.Context;
import javax.ws.rs.core.UriInfo;

@Stateless
@Path("test")
public class TestRestReceiver {
    private final static Logger logger = LoggerFactory.getLogger(TestRestReceiver.class);

    @Context
    private UriInfo uriInfo;

    @GET
    @Path("logStatus")
    public String logStatus() {
        logger.info("Path: {}", uriInfo.getAbsolutePath());

        return "OK";
    }
}

Można wstrzyknąć UriInfo również jako atrybut metody:

package pl.marceen.test.boundary;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import javax.ejb.Stateless;
import javax.ws.rs.GET;
import javax.ws.rs.Path;
import javax.ws.rs.core.Context;
import javax.ws.rs.core.UriInfo;

@Stateless
@Path("test")
public class TestRestReceiver {
    private final static Logger logger = LoggerFactory.getLogger(TestRestReceiver.class);

    @GET
    @Path("logStatus")
    public String logStatus(@Context UriInfo uriInfo) {
        logger.info("Path: {}", uriInfo.getAbsolutePath());

        return "OK";
    }
}

EntityManager - find list of objects

public List<Element> findAllElements(Task task) {
    logger.info("Try to find elements - task: {}", task.getId());

    return em.createNamedQuery(Element.FIND_ALL_BY_TASK, Element.class)
               .setParameter("task", task)
               .getResultList();
}

Convert public certificate to Base64

String base64Encoded = Base64.encodeToString(pubkey.getEncoded(), Base64.DEFAULT).
    replaceAll("\n", "");

Testy logów z log4j

Tworzymy klasę w /src/test/java/pakiet

import org.apache.log4j.AppenderSkeleton;
import org.apache.log4j.Level;
import org.apache.log4j.Logger;
import org.apache.log4j.spi.LoggingEvent;

import java.util.ArrayList;
import java.util.List;

public class LogsHistorySaver extends AppenderSkeleton {
    private List logs;

    public void setUp() {
        logs = new ArrayList<>();
        Logger.getRootLogger().addAppender(this);
    }

    public void tearDown() {
        Logger.getRootLogger().removeAppender(this);
    }

    public List getLogs() {
        return logs;
    }

    @Override
    protected void append(LoggingEvent event) {
        logs.add(new Event(event.getLevel(), String.valueOf(event.getMessage())));
    }

    @Override
    public void close() {

    }

    @Override
    public boolean requiresLayout() {
        return false;
    }

    public class Event {
        private Level level;
        private String message;

        Event(Level level, String message) {
            this.level = level;
            this.message = message;
        }

        public Level getLevel() {
            return level;
        }

        public String getMessage() {
            return message;
        }

        @Override
        public String toString() {
            final StringBuilder sb = new StringBuilder("Event{");
            sb.append("level=").append(level);
            sb.append(", message='").append(message).append('\'');
            sb.append('}');
            return sb.toString();
        }
    }
}

I korzystamy w niej w teście w spoób następujący:

public class KaboomTest {

    private Kaboom sut;

    private LogsHistorySaver logsHistorySaver = new LogsHistorySaver();

    @Before
    public void setUp() throws Exception {
        logsHistorySaver.setUp();
    }

    @Test
    public void log() throws Exception {
        //when
        sut.build();

        //then
        List logs = logsHistorySaver.getLogs();

        assertThat(logs.size()).isEqualTo(3);
        assertThat(logs.get(0).getLevel()).isEqualTo(Level.INFO);
        assertThat(logs.get(0).getMessage()).isEqualTo("First log");
        assertThat(logs.get(1).getLevel()).isEqualTo(Level.INFO);
        assertThat(logs.get(1).getMessage()).isEqualTo("Second log");
        assertThat(logs.get(2).getLevel()).isEqualTo(Level.INFO);
        assertThat(logs.get(2).getMessage()).isEqualTo("Third log");
    }
}

Mockito - mock final class

Mockito w wersji 2.4.2 umożliwia mockowanie finalnych klas (oraz metod).

Wystarczy dodać plik

src/test/resources/mockito-extensions/org.mockito.plugins.MockMaker

zawierający jedną linię tekstu:

mock-maker-inline

Maven dependency:

    org.mockito
    mockito-core
    2.4.2

Stream zamiast forEach

Bez użycia streama (trzeba definiować listę obiektów):

private List buildTransactions(AccountNumber accountNumber) {
    List transactions = new ArrayList<>();
    accountNumber
        .getAccountHistoryList()
        .forEach(accountHistory -> transactions.add(transactionBuilder.build(accountHistory)));

    return transactions;
}

Używając streama możemy tworzenie listy obiektów pominąć:

private List buildTransactions(AccountNumber accountNumber) {
    return accountNumber
        .getAccountHistoryList()
        .stream()
        .map(accountHistory -> transactionBuilder.build(accountHistory))
        .collect(Collectors.toList());
}

Update: Można jeszcze bardziej elegancko:

private List buildTransactions(AccountNumber accountNumber) {
    return accountNumber
        .getAccountHistoryList()
        .stream()
        .map(transactionBuilder::build)
        .collect(Collectors.toList());
}

Optional.ofNullable().orElseThrow()

Przykład wykorzystania klasy Optional dostępnej od Java 8.

Bez Optionala

public void test(Task task) throws VerificationException {
    if (task.getCustomer() == null) {
        logger.error(CUSTOMER_NOT_FOUND);
        throw BmVerificationException.badRequest(CUSTOMER_NOT_FOUND);
    }
}

Z Optionalem

public void test(Task task) throws VerificationException {
    Optional.ofNullable(task.getCustomer()).orElseThrow(this::getException);
}

private VerificationException getException() {
    logger.error(CUSTOMER_NOT_FOUND);
    return VerificationException.badRequest(CUSTOMER_NOT_FOUND);
}

AssertJ - assertThatExceptionOfType

Przykład alternatywnego testowania wyjątku - assertThatExceptionOfType

public class FooTest {

    @Rule
    public MockitoRule mockitoRule = MockitoJUnit.rule();

    @Mock
    private Validator validator;

    @InjectMocks
    private Foo sut;

    private HistoryRequest historyRequest;

    @Before
    public void setUp() throws Exception {
        historyRequest = new HistoryRequest();
    }

    @Test
    public void getHistoryThrowsExceptionDueToAccessDenied() throws Exception {
        when(validator.validate(historyRequest)).thenReturn(new Client());

        assertThatExceptionOfType(BloggerException.class)
                .isThrownBy(() -> sut.getHistory(historyRequest))
                .withMessage("Access denied");
    }
}

GSON - ignorowanie pól przy pomocy własnej adnotacji

Tworzymy własną adnotację:

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public @interface Exclude {
}

Klasę implementującą ExclusionStrategy:

import com.google.gson.ExclusionStrategy;
import com.google.gson.FieldAttributes;

public class AnnotationExclusionStrategy implements ExclusionStrategy {

    @Override
    public boolean shouldSkipField(FieldAttributes f) {
        return f.getAnnotation(Exclude.class) != null;
    }

    @Override
    public boolean shouldSkipClass(Class clazz) {
        return false;
    }
}

Wykorzystujemy utworzoną adnotację w POJO:

public abstract class ExampleRequest {

    protected Long requestTime;
    protected String clientCode;
    @Exclude
    protected String hash;
}

Budujemy gsona np w taki sposób:

public class TestFacade {
    private static final Gson GSON;

    static {
        JsonDeserializer longToDateAdapter = (json, typeOfT, context) -> new Date(json.getAsJsonPrimitive().getAsLong());
        GSON = new GsonBuilder()
                .setDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSSZ")
                .registerTypeAdapter(Date.class, longToDateAdapter)
                .setExclusionStrategies(new AnnotationExclusionStrategy())
                .create();
    }
}

Najważniejsza w tym przykładzie jest metoda setExclusionStrategies(new AnnotationExclusionStrategy()) dzięki której cała magia działa. źródło: http://stackoverflow.com/a/27986860/767529

Tesseract pod Centos - JNA problem

Problem:

Caused by: java.lang.UnsatisfiedLinkError: /tmp/jna-1347637353/jna2637488223705099160.tmp: /tmp/jna-1347637353/jna2637488223705099160.tmp: failed to map segment from shared object: Operation not permitted
        at java.lang.ClassLoader$NativeLibrary.load(Native Method) [rt.jar:1.8.0_77]
        at java.lang.ClassLoader.loadLibrary0(ClassLoader.java:1941) [rt.jar:1.8.0_77]
        at java.lang.ClassLoader.loadLibrary(ClassLoader.java:1824) [rt.jar:1.8.0_77]
        at java.lang.Runtime.load0(Runtime.java:809) [rt.jar:1.8.0_77]
        at java.lang.System.load(System.java:1086) [rt.jar:1.8.0_77]
        at com.sun.jna.Native.loadNativeDispatchLibraryFromClasspath(Native.java:851) [jna-4.2.2.jar:4.2.2 (b0)]
        at com.sun.jna.Native.loadNativeDispatchLibrary(Native.java:826) [jna-4.2.2.jar:4.2.2 (b0)]
        at com.sun.jna.Native.(Native.java:140) [jna-4.2.2.jar:4.2.2 (b0)]
        at net.sourceforge.tess4j.TessAPI1.(TessAPI1.java:41) [tess4j-3.1.0.jar:3.1.0]

Rozwiązanie problemu:

Taki problem występuje ponieważ katalog /tmp jest noexec. Są dwa sposoby na rozwiązanie tego problemu. Można usunąć noexec z /tmp albo zdefiniować inne miejsce zapisu dla tmp natywnych bibliotek. Ja wybrałem ten drugi sposób i ładnie działa. Wystarczy dopisać:

-Djava.io.tmpdir=/jakis_katalog/tmp

źródło: cloudbees.zendesk.com

Java z automatyczną akceptacją licencji

Instalacja Java pod Ubuntu z automatyczną akceptacją licencji. Taka możliwość może być przydatna przy instalacji składników ze skryptu - np. przy stawianiu systemu w środowisku Docker'a (w Dockerfile).

echo "oracle-java8-installer shared/accepted-oracle-license-v1-1 select true" | sudo debconf-set-selections
sudo apt-get install -y oracle-java8-installer

JavaEE - Annotation Type Schedule

Za pomocą adnotacji @Schedule istnieje możliwość odpalenia kawałka kodu w określonych odcinkach czasu - jest to coś podobnego do Cron'a na serwerach linuksowych.

Poniżej przestawiam przykład, w którym widać zastosowanie tej adnotacji - Metoda init() będzie uruchamiana co 5 minut.

package pl.marceen.schedule;

import org.apache.log4j.Logger;

import javax.ejb.Schedule;
import javax.ejb.Singleton;
import javax.ejb.Startup;

/**
 * @author Marcin Zaremba
 */
@Singleton
@Startup
public class ScheduleTest {

    private static final Logger logger = Logger.getLogger(ScheduleTest.class);

    @Schedule(persistent = false, hour = "*", minute = "*/5")
    public void init() {
        logger.info("Method init() started.");
    }

}

Więcej możliwościach tej adnotacji: docs.oracle.com

Can't find a persistence unit named null in deployment

Podczas zabaw z Javą, JPA oraz JBoss napotkałem na problem, przez który straciłem troszkę chwil życia. Przy próbie użycia annotacji @PersistenceContext otrzymywałem błąd serwera: Can't find a persistence unit named null in deployment (...).

Problem okazał się trywialny - mój IDE (Intellij IDEA) przy instalacji JPA utworzył plik persistence.xml w niewłaściwym miejscu. Aby zatem rozwiązać ten kosmiczny problem wystarczy przenieść plik persistence.xml do katalogu your_app_name\src\main\resources\META-INF.

żródło: stackoverflow.com

Install Oracle JDK on Linux Mint 17.3

Ściągamy (do katalogu Pobrane) najnowsze JDK ze strony Oracle w odpowiedniej dla systemu operacyjnego wersji (32-bit lub 64-bit). Następnie rozpakowujemy ściągnięty plik, odpalamy terminal i wpisujemy:

sudo apt-get update
sudo apt-get remove openjdk*
sudo mkdir -p /opt/java
sudo mv ~/Pobrane/jdk1.8.0_65 /opt/java/
sudo update-alternatives --install "/usr/bin/java" "java" "/opt/java/jdk1.8.0_65/bin/java" 1
sudo update-alternatives --set java /opt/java/jdk1.8.0_65/bin/java
java --version

źródło: community.linuxmint.com

Android 5.0.1 i Nexus 4 - instalacja pod Linux Mint 17

Aby zainstalować najnowszego w tej chwili Androida (5.0.1) na telefonie Nexus 4 w środowisku linuksowym (Mint 17) wystarczy kilka małych kroków.

Instalacja Java JDK

Przede wszystkim zaczynamy od zainstalowania Oraclowej Javy JDK - poniżej instrukcja jak tego dokonać:

• Usuwamy openjdk

sudo apt-get update && apt-get remove openjdk*

• Ściągamy Java JDK ze strony Oracle.

• Rozpakowujemy ściągnięty plik

tar -zxvf jdk-...

• Tworzymy katalog java w katalogu opt

sudo mkdir -p /opt/java

• Przenosimy rozpakowaną javę do nowo utworzonego katalogu java (w moim przypadku to jdk1.8.0_25 ale w Twoim może być już inna)

sudo mv jdk1.8.0_25 /opt/java

• Ustawiamy zainstalowaną JDK jako domyślną

sudo update-alternatives --install "/usr/bin/java" "java" "/opt/java/jdk1.8.0_25/bin/java" 1
sudo update-alternatives --set java /opt/java/jdk1.8.0_25/bin/java

• Nadajemy uprawnienia

sudo chmod 0775 /usr/bin/java
sudo chmod -R 0775 /opt/java/jdk1.8.0_25/

• Sprawdzamy czy wszystko gra

java -version

Instalacja Android Studio

Aby zainstalować platform-tools/ i móc cieszyć się poleceniami fastboot czy adb wystarczy zainstalować Android Studio.

Uruchomienie modułu debuggowania USB w telefonie

Aby móc połączyć się z telefonem należy uruchomić moduł debuggowania USB. Opcja ta znajduje się w ustawieniach telefonu w zakładce "Opcje programistyczne". Domyślnie opcje programistyczne są niewidoczne - aby je aktywować należy wejść w "Informacje o telefonie" i siedem razy kliknąć w Numer kompilacji.

Sprawdzenie połączenia komputera z telefonem

Aby sprawdzić czy telefon jest widoczny przez system operacyjny komputera można uruchomić przykładowe polecenie:

adb reboot bootloader

Wcześniej oczywiście należy podłączyć telefon z komputerem przy pomocy kabla USB. Jeśli telefon zrestartuje się i przejdzie do bootloadera to znaczy, że wszystko jest ok.

Instalacja systemu Android 5.0.1

Aby zainstalować Androida 5.0.1 należy wejść na stronę https://developers.google.com/android/nexus/images pobrać odpowiednią wersję systemu i wykonać polecenia znajdujące się w dziale Flashing Instructions.