Archív

Archive for the ‘Java’ Category

SLF4J, Log4J 2, LogMX – logování

2013-06-02 Komentáře vypnuty
  • SLF4J is simple facade or abstraction for various logging frameworks (e.g. java.util.logging, logback, log4j) allowing the end user to plug in the desired logging framework at deployment time.
  • Log4J 2 is an upgrade to Log4j that provides significant improvements
  • LogMX is an intuitive and easy-to-use cross platform graphical tool for developers and administrators working with log and trace files.
  1. Stáhni SLF4J a rozbal následující knihovny do: GLASSFISH_HOME\glassfish\lib\
    • jul-to-slf4j.jar
    • slf4j-api.jar
  2. Vytvoř soubor GLASSFISH_HOME\glassfish\domains\dev\config\slf4j_logging.properties:
            handlers = org.slf4j.bridge.SLF4JBridgeHandler
            com.sun.enterprise.server.logging.GFFileHandler.flushFrequency=1
            com.sun.enterprise.server.logging.GFFileHandler.file=${com.sun.aas.instanceRoot}/logs/server.log
            com.sun.enterprise.server.logging.GFFileHandler.rotationTimelimitInMinutes=0
            com.sun.enterprise.server.logging.GFFileHandler.logtoConsole=false
            com.sun.enterprise.server.logging.GFFileHandler.rotationLimitInBytes=2000000
            com.sun.enterprise.server.logging.GFFileHandler.alarms=false
            com.sun.enterprise.server.logging.GFFileHandler.formatter=com.sun.enterprise.server.logging.UniformLogFormatter
            com.sun.enterprise.server.logging.GFFileHandler.retainErrorsStasticsForHours=0
            
  3. Nastav cestu v java property k tomuto configuráku
    • Buď edituj GLASSFISH_HOME\glassfish\domains\dev\config\domain.xml:
                      <jvm-options ... >
                      ...
                      -Djava.util.logging.config.file=${com.sun.aas.instanceRoot}/config/slf4j_logging.properties
                      ...
                      </jvm-options>
                      
    • Nebo pomocí Glassfish asadmin
  4. Stáhni Log4J2 a rozbal následující knihovny do: GLASSFISH_HOME\glassfish\lib\
    • log4j-api.jar
    • log4j-core.jar
  5. Vytvoř konfigurační soubor log4j2.xml
            <?xml version='1.0' encoding='UTF-8'?>
            <configuration name="SpringWS" monitorInterval="5">
    
                <properties>
                    <property name="pattern1">%d %p %c [%t] %m%n</property>
                    <property name="pattern2">%d %p %c{1.} [%t] %m%n</property>
                </properties>
    
                <appenders>
                    <RollingFile name="RollingFile"
                                 fileName="c:/java/logs/my_app.log"
                                 filePattern="c:/java/logs/$${date:yyyy-MM}/my_app-%d{yyyy-MM-dd}-%i.log.gz">
                        <PatternLayout>
                            <pattern>${pattern1}</pattern>
                        </PatternLayout>
                        <Policies>
                            <TimeBasedTriggeringPolicy/>
                            <SizeBasedTriggeringPolicy size="100 KB"/>
                        </Policies>
                    </RollingFile>
                </appenders>
    
                <loggers>
                    <!--
                    <root level="trace">
                        <appender-ref ref="RollingFile"/>
                    </root>
                    -->
                    <!-- name must be package or package.Class -->
                    <logger name="example" level="trace" additivity="false">
                        <appender-ref ref="RollingFile"/>
                    </logger>
                </loggers>
    
            </configuration>
            
  6. A opět java property k tomuto configuráku
    • GLASSFISH_HOME\glassfish\domains\dev\config\domain.xml:
                      <jvm-options... >
                      ...
                      -Dlog4j2.configurationFile=${com.sun.aas.instanceRoot}/config/log4j2.xml
                      ...
                      </jvm-options>
                      
    • Nebo pomocí Glassfish asadmin
  7. Přidej Log4J 2 závislost do pom.xml:
            <dependency>
                <groupId>org.apache.logging.log4j</groupId>
                <artifactId>log4j-api</artifactId>
                <version>2.0-beta6</version>
                <scope>provided</scope>
            </dependency>
            <dependency>
                <groupId>org.apache.logging.log4j</groupId>
                <artifactId>log4j-core</artifactId>
                <version>2.0-beta6</version>
                <scope>provided</scope>
            </dependency>
            
  8. Přidej logger do kódu:
  9.         import org.apache.logging.log4j.LogManager;
            import org.apache.logging.log4j.Logger;
    
            public class MyClass {
                Logger logger = LogManager.getLogger(MyClass.class.getName());
    
                public void someMethod() {
    
                    logger.trace("Entering method {0}.", someProperty);
            
  10. Restartuj server
  11. Stáhni nějaký log viewer, např. LogMX
    LogMX parser setting
Rubriky:GlassFish, Java, Logging

Začínáme s JSF & PrimeFaces

2012-11-12 Komentáře vypnuty
  • JavaServer Faces (JSF) is a Java-based web application framework intended to simplify development integration of web-based user interfaces
  • PrimeFaces is today most used JSF component library
  1. Přidej JSF a PrimeFaces do Maven scriptu pom.xml
            <!-- JSF 2.1 -->
            <dependency>
                <groupId>javax.faces</groupId>
                <artifactId>javax.faces-api</artifactId>
                <version>2.1</version>
                <scope>provided</scope>
            </dependency>
            <!-- PrimeFaces -->
            <dependency>
                <groupId>org.primefaces</groupId>
                <artifactId>primefaces</artifactId>
                <version>3.3.1</version>
            </dependency>
    
            <!-- GlassFish repository (contains JSF) -->
            <repository>
                <id>GlassFish</id>
                <url>http://download.java.net/maven/glassfish</url>
            </repository>
            <!-- PrimeFaces repository -->
            <repository>
                <id>prime-repo</id>
                <name>Prime Repo</name>
                <url>http://repository.primefaces.org</url>
            </repository>
    
    
  2. Vytvoř POJO třídu Employee.java s getry a setry
    public class Employee {
        private int id;
        private String firstName;
        private String lastName;
    
  3. Vytvoř controller s privátní proměnnou a metodou, která ji naplní daty
    @ManagedBean
    @ViewScoped
    public class EmployeeController {
        private List<Employee> employeeList = new ArrayList<>();
    
        public void showAllEmployees() {
            Employee employee1 = new Employee();
            employee1.setId(1);
            employee1.setFirstName("John");
            employee1.setLastName("Black");
    
            Employee employee2 = new Employee();
            employee2.setId(1);
            employee2.setFirstName("Michael");
            employee2.setLastName("Knight");
    
            employeeList.add(employee1);
            employeeList.add(employee2);
        }
    
  4. Vytvoř stránku index.xhtml
    <?xml version="1.0" encoding="UTF-8"?>
    <!DOCTYPE html
            PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
            "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
    
    <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en"
          xmlns:f="http://java.sun.com/jsf/core"
          xmlns:h="http://java.sun.com/jsf/html"
          xmlns:p="http://primefaces.org/ui">
    
    <h:head>
        <title>Create a new employee</title>
    </h:head>
    
    <h:body>
    
        <h:form>
            <p:dataTable var="employee" value="#{employeeController.employeeList}">
                <p:column headerText="ID">
                    <h:outputText value="#{employee.id}"/>
                </p:column>
    
                <p:column headerText="First name">
                    <h:outputText value="#{employee.firstName}"/>
                </p:column>
    
                <p:column headerText="Last name">
                    <h:outputText value="#{employee.lastName}"/>
                </p:column>
            </p:dataTable>
        </h:form>
    
        <h:form>
            <h:commandButton value="Show All Employees" type="submit" action="#{employeeController.showAllEmployees}"/>
        </h:form>
    
    </h:body>
    </html>
    
    • komponenta p:dataTable je použita z PrimeFaces
    • stisknutím tlačítka dojde k vyvolání akce showAllEmployees, respektive metody showAllEmployees()
  5. Zadej URL http://127.0.0.1:9090/hr-0.1-SNAPSHOT/index.faces

Rubriky:Java, JSF 2, Maven

Začínáme s EJB 3.1

2012-11-07 Komentáře vypnuty
  • Přidej EJB do Maven scriptu pom.xml
    <!-- EJB -->
    <dependency>
        <groupId>org.glassfish</groupId>
        <artifactId>javax.ejb</artifactId>
        <version>3.1</version>
        <scope>provided</scope>
    </dependency>
    
    <!-- Java.net GlassFish repository (contains EJB) -->
    <repository>
        <id>glassfish</id>
        <name>Glassfish Repository</name>
        <url>http://download.java.net/maven/glassfish</url>
    </repository>
    
  • Přidej některou z EJB anotací (např. @Stateless) do existující třídy
    @Stateless
    public class EmployeeDao {
    
        @PersistenceContext(unitName = "WebAppPersistenceUnit")
        private EntityManager em;
    
        public Employee findEmployeeById(int id) {
            Employee employee = em.find(Employee.class, id);
            return employee;
        }
    }
    
  • Nyní můžeš vytváření objektů delegovat na Dependency Injection
        // vytvoření instance pomocí konstruktoru
        private EmployeeDao employeeDao = new EmployeeDao();
        // použití DI
        @EJB
        private EmployeeDao employeeDao;
    
Rubriky:EJB 3.1, Java, Maven

Začínáme s JPA 2

2012-11-06 Komentáře vypnuty
  • JPA je pouze standart
  • referenční implementace: EclipseLink
  • další implementací je např. Hibernate
  1. Přidej IDEA > Tools > Data Sources
  2. Vytvoř na serveru připojení k databázi DataSource 
  3. Uprav Maven script pom.xml
    
            <!-- JPA -->
            <dependency>
                <groupId>org.eclipse.persistence</groupId>
                <artifactId>eclipselink</artifactId>
                <version>${eclipselink.version}</version>
                <scope>provided</scope>
            </dependency>
    
            <!-- EclipseLink, http://wiki.eclipse.org/EclipseLink/Maven -->
            <repository>
                <id>EclipseLink</id>
                <url>http://download.eclipse.org/rt/eclipselink/maven.repo</url>
            </repository>
    
  4. Vytvoř POJO třídu (respektive Entitu) Employee.java včetně SET a GET metod
    public class Employee {
    
        private int id;
        private String firstName;
        private String lastName;
    
    
  5. Vytvoř mapovací soubor employee.xml. Pro přehlednost vytvoř stejnou strukturu balíčků ve složce resources jakou máš ve java. Případně použij místo anotace místo xml konfigurace (odstavec na konci).
    <?xml version="1.0" encoding="UTF-8"?>
    <entity-mappings xmlns="http://java.sun.com/xml/ns/persistence/orm"
                     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
                     version="2.0">
    
        <description>The minimal mappings for a persistent entity in XML.</description>
    
        <entity name="Employee" class="com.unfuddle.kamiluv.hr.Employee" access="FIELD">
    
            <!-- Table name -->
            <table name="EMPLOYEES"/>
    
            <!-- Queries -->
            <named-query name="findAllEmployees">
                <query>SELECT e FROM Employee e</query>
            </named-query>
    
            <!-- Attributes -->
            <attributes>
                <id name="id">
                    <column name="EMPLOYEE_ID"/>
                </id>
                <basic name="firstName">
                    <column name="FIRST_NAME"/>
                </basic>
                <basic name="lastName">
                    <column name="LAST_NAME"/>
                </basic>
            </attributes>
    
        </entity>
    
    </entity-mappings>
    
    
  6. Vytvoř src\main\resources\META-INF\persistence.xml
    <?xml version="1.0" encoding="UTF-8"?>
    <persistence xmlns="http://java.sun.com/xml/ns/persistence"
                 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
                 xsi:schemaLocation="http://java.sun.com/xml/ns/persistence http://java.sun.com/xml/ns/persistence/persistence_2_0.xsd"
                 version="2.0">
    
        <persistence-unit name="WebAppPersistenceUnit" transaction-type="JTA">
            <provider>org.eclipse.persistence.jpa.PersistenceProvider</provider>
            <jta-data-source>jdbc/hr_datasource</jta-data-source>
            <mapping-file>com/wordpress/kamiluv/hr/employee.xml</mapping-file>
            <class>com.wordpress.kamiluv.hr.Employee</class>
    
            <properties>
                <property name="eclipselink.logging.level" value="INFO"/>
            </properties>
    
        </persistence-unit>
    </persistence>
    
    
    • jta-data-source odkazuje na DataSource na serveru (krok 2)
    • pokud je vše v pořádku a IntelliJ IDEA rozpozná JPA configuraci, přidá ikonky pro rychlé přecházení do POJO třídy…

  7. Vytvoř třídu EmployeeDAO
    public class EmployeeDAO {
    
        @PersistenceContext(unitName = "WebAppPersistenceUnit")
        private EntityManager em;
    
        public List<Employee> findAllEmployees() {
            TypedQuery<Employee> query = em.createNamedQuery("findAllEmployees", Employee.class);
            return query.getResultList();
        }
    }
    

Pokud dáváš přednost anotacím před xml konfigurací (bohužel se mi nepodařilo zprovoznit oboji najednou):

  • odstraň tag mapping-file z persistence.xml
  • odstraň konfigurační soubor employee.xml
  • přidej anotace do POJO třídy
    @Entity
    @NamedQuery(name = "findAllEmployees", query = "SELECT e FROM Employee e")
    @Table(name = "EMPLOYEES")
    public class Employee {
    
        @Id
        @Column(name = "EMPLOYEE_ID")
        private int id;
        @Column(name = "FIRST_NAME")
        private String firstName;
        @Column(name = "LAST_NAME")
        private String lastName;
    
        // getters & setters
    }
    

Číselné typy v Javě a SQL

2012-03-13 Komentáře vypnuty
int, long & NUMBER

One paranoid delusional fear that programmers frequently have is running out of sequence numbers. Since most sequence strategies just keep incrementing a number it is unavoidable that you will eventually run out. However as long a large enough numeric precision is used to store the sequence id this is not an issue. For example if you stored your id in a NUMBER(5) column, this would allow 99,999 different ids, which on most systems would eventually run out. However if you store your id in a NUMBER(10) column, which is more typical, this would store 9,999,999,999 ids, or one id each second for about 300 years (longer than most databases exist). But perhaps your system will process a lot of data, and (hopefully) be around a very long time. If you store your id in a NUMBER(20) this would be 99,999,999,999,999,999,999 ids, or one id each millisecond for about 3,000,000,000 years, which is pretty safe.

But you also need to store this id in Java. If you store the id in a Java int, this would be a 32 bit number , which is 4,294,967,296 different ids, or one id each second for about 200 years. If you instead use a long, this would be a 64 bit number, which is 18,446,744,073,709,551,616 different ids, or one id each millisecond for about 600,000,000 years, which is pretty safe.

  • int (32 bit number, 4,294,967,296 different ids) ≈ NUMBER(10)
  • long (64 bit number, 18,446,744,073,709,551,616 different ids) ≈ NUMBER(20)
 
Source:
NUMBER vs. VARCHAR2

Q: When should I use NUMBER and when should I use VARCHAR2?

A: If you need to perform mathematical operations on a value, use NUMBER. If you are not doing math (or if the values are not used as mathematical values), store the value in a VARCHAR2.

Example: You have a data warehouse and you store an account number and a sale price. Sale price may be added or multiplied so it is NUMBER. Account number may be all numeric digits but it makes no sense to perform mathematical operations against it. Store account number as VARCHAR2.

Even if your application will not perform math against the sale price, store it as NUMBER because it makes sense to perform math against it. This is pretty much a common sense thing to me.

There is always an exception. Surrogate keys (as in sequences) – store them as a NUMBER. While you won’t be adding and subtracting them, there are benefits to storing them as a NUMBER. For one thing, you will not have to convert from numeric (result of a sequence) to string to store them.

Source:
Rubriky:Databáze, Java

Úrovně výjimek Log4J

2012-03-12 Komentáře vypnuty

TRACE
Nejnižší úroveň, obvykle vypisujeme pouze do souboru. Vhodné pro různé check-pointy (metoda zavolána, různé počítadla pro ladící účely). Tato úroveň může obsahovat mnoho zpráv, často je programátory nevyužívána a je psáno zbytečně mnoho informací do úrovně DEBUG.

DEBUG
Ladící hlášky, které pomáhají zákazníkovi identifikovat prvotní problém, případně vytvořit report pro dodavatele, aby mohl chybu opravit. V DEBUG by nemělo být příliš hlášek, ale zároveň by tato úroveň měla poskytovat dostatek informací k tomu, aby mohlo být zpětně zjištěno, v čem je problém.

INFO
Hlášky INFO obvykle nejsou vypisovány ve standardní instalaci, ale zákazník si může zvýšit vypisování z WARN na INFO a měl by vidět o něco více informací. Hlášky INFO jsou vhodné zejména pro různé informační zprávy typu něco se startuje, server znovu načetl konfiguraci nebo že aplikace načítá soubor z disku.

WARN
Tato úroveň by měla být zapnuta v implicitní instalaci softwaru, program informuje o události, která není obvyklá. Příklad – potřebná konfigurační hodnota nebyla nalezena v konfiguraci, program použije   defaultní hodnotu. Je vždy dobré se zamyslet, jestli daná je daná hláška chybou (ERROR), varováním (WARN) nebo dokonce pouze informativního charakteru (INFO).

ERROR
V aplikaci došlo k chybovému stavu, který však nenaruší běh programu. Typicky například nemohl být zpracován požadavek na serveru kvůli špatné konfiguraci nebo třeba chyba vstupních dat – program neprovede svoji činnost, ale čeká na další (validní) vstup.

FATAL
Došlo k vyjímečnému stavu a program ukončuje svoji činnost. Například soubor nebyl vůbec nalezen, chyba v programu nebo došla paměť.

Rubriky:Java, Logging