JSF odkazy

2013-09-25 Komentáře vypnuty
Rubriky:JSF 2

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
    }
    

Jak importovat DataSource do GlassFish serveru

2012-11-06 Komentáře vypnuty
  • Data sources a connection pools můžeme nastavit ručně přímo ve webovém rozhraní GlassFish serveru – v Admin consoli, nebo použít script s konfigurací:
  1. Stáhni Oracle JDBC driver ojdbc6.jar a ulož jej do %GLASSFISH_HOME%\glassfish\domains\DEV\lib\ext\
  2. Zkopíruj si template %GLASSFISH_HOME%\glassfish\lib\install\templates\ resources\jdbc\oracle_type4_datasource.xml do pracovního adresáře.
  3. Přejmenuj na datasources_HR.xml a uprav:
    <resources>
        <!-- HR -->
        <jdbc-connection-pool
            name="hr_pool"
            datasource-classname="oracle.jdbc.pool.OracleDataSource"
            res-type="javax.sql.DataSource">
            <property name="url" value="jdbc:oracle:thin:@127.0.0.1:1521:XE"/>
            <property name="user" value="HR"/>
            <property name="password" value="hr"/>
        </jdbc-connection-pool>
    
        <jdbc-resource
            enabled="true"
            jndi-name="jdbc/hr_datasource"
            object-type="user"
            pool-name="hr_pool"
        />
    </resources>
    
  4. Vytvoř soubor s heslem pwd.txt:
    AS_ADMIN_PASSWORD=admin
    
  5. Vytvoř .bat script pro import:
    set GLASSFISH_HOME=c:\java\server\glassfish3
    start %GLASSFISH_HOME%\bin\asadmin --user admin --passwordfile pwd.txt --port 9000 add-resources datasources_HR.xml
    
  6. Funkčnost databázového spojení si můžeš ověřit přímo v Admin consoli nebo pomocí .bat scriptu:
    set GLASSFISH_HOME=c:\java\server\glassfish3
    start %GLASSFISH_HOME%\bin\asadmin --user admin --passwordfile pwd.txt --port 9000 ping-connection-pool hr_pool
    

IntelliJ IDEA 11.x Set-Up

2012-04-12 Komentáře vypnuty

Mandatory settings

  • IDEA settings
  1. File > Settings > Compiler > Java Compiler
    • Maximum heap size (MB): 512
  2. File > Settings > Code Style > Java > tab JavaDoc > Other:
    • Tick “Do not wrap one line comments”
  3. File > Settings > Code Style > XML > tab Other:
    • UnTick “Wrap text”
  4. File > Settings > Code Style > Java > tab Imports > General:
    • Enter into “Class count to use import with ‘*’”: 99999
    • Enter into “Names count to use static import with ‘*’”: 99999
  5. File > Settings > File Templates > tab Includes:
    • Change File Header
      /**
      * <<Put comment here>>
      *
      * @author Name
      * ${YEAR}-${MONTH}-${DAY}
      * @version 2.1
      * @since 1.0
      */
  6. File > Settings > Maven
    • Checksum policy: warn
  7. File > Settings > Maven > Runner:
    • Set VM Parameters: -Xmx512m
  • Project settings
  1. File > Project structure:
    • SDKs: Use sign „Plus“ to add JDK path
    • Project: set SDK
    • Project: Project language level

Optional settings

  1. File > Settings > Editor:
    • UnTick “Allow placement of caret after end of line”
    • Tick “Highlight usages of element at caret”
  2. File > Settings > Editor > Appearance:
    • Tick “Show line numbers”
    • Tick “Show method separators”
    • Tick “Show breadcrumbs for XML files”
  3. File > Settings > Editor > Editor Tabs:
    • Increase “Tab limit:” 99 (or higher)

Rubriky:IntelliJ IDEA