Java - wyrażenia regularne regex/maski

Przykładowa walidacja/maski za pomocą wyrażeń regularnych:

public class RegExTest {
    public static void main(String[] args) {
       
        System.out.print("\\a{5}\\d{15} ");
        String path = "abcde123456789012345";
        String regularExpression = "([A-Za-z]{5}+[0-9]{15})";
        Pattern pattern = Pattern.compile(regularExpression);
        System.out.print(pattern.matches(regularExpression, path));
        regularExpression = "([A-Za-z]{5}\\d{15})";
        pattern = Pattern.compile(regularExpression);
        System.out.println(pattern.matches(regularExpression, path));
       
        System.out.print("\\a{2,} ");
        path = "ab";
        regularExpression = "[A-Za-z]{2,}";
        pattern = Pattern.compile(regularExpression);
        System.out.println(pattern.matches(regularExpression, path));

        System.out.print("\\w{3,} ");
        path = "a0_";
        regularExpression = "[A-Za-z0-9_]{3,}";
        regularExpression = "\\w{3,}";
        pattern = Pattern.compile(regularExpression);
        System.out.println(pattern.matches(regularExpression, path));
       
        System.out.print("\\d{11} ");
        path = "12345678901";
        regularExpression = "[0-9]{11}";
        pattern = Pattern.compile(regularExpression);
        System.out.print(pattern.matches(regularExpression, path)+"/");
       
        regularExpression = "\\d{11}";
        pattern = Pattern.compile(regularExpression);
        System.out.println(pattern.matches(regularExpression, path));
       
        System.out.print("[tTnN]{1} ");
        path = "t";
        regularExpression = "[tTnN]{1}";
        pattern = Pattern.compile(regularExpression);
        System.out.println(pattern.matches(regularExpression, path));
       
        System.out.print("[\\w\\d[:punct:]] ");
        path = "1";
        regularExpression = "[\\w\\d\\p{Punct}]{1,}";
        pattern = Pattern.compile(regularExpression);
        System.out.println(pattern.matches(regularExpression, path));

        System.out.print("\\d{2}-\\d{3} ");
        path = "21-010";
        regularExpression = "\\d{2}-\\d{3}";
        pattern = Pattern.compile(regularExpression);
        System.out.println(pattern.matches(regularExpression, path));
       
        System.out.print("\\w ");
        path = "gfasg4wer454351235Fw_";
        regularExpression = "[A-Za-z0-9_]{1,}";
        pattern = Pattern.compile(regularExpression);
        System.out.print(pattern.matches(regularExpression, path)+"/");
       
        regularExpression = "\\w{1,}";
        pattern = Pattern.compile(regularExpression);
        System.out.println(pattern.matches(regularExpression, path));

        System.out.print("^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\\.[a-zA-Z0-9-.]+$ ");
        path = "konto@komena.pl";
        regularExpression = "^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\\.[a-zA-Z0-9-.]+$";
        pattern = Pattern.compile(regularExpression);
        System.out.println(pattern.matches(regularExpression, path));
       
        System.out.print("\\d{9} ");
        path = "123456789";
        regularExpression = "\\d{9}";
        pattern = Pattern.compile(regularExpression);
        System.out.println(": "+pattern.matches(regularExpression, path));

        String input = "linea\nlineb\nlinec";
        Pattern p = Pattern.compile("(?i)lineb", Pattern.DOTALL);
        Matcher m = p.matcher(input);
        boolean b = m.find();
        System.out.println("match found: " + b);
    }
}

Apache Camel - Wczytanie XML / JAXB

 [Apache Camel 2.8.0, JAXB, Jboss 6]
Przykład zaczytanie pliku XML do obiektu JAVA, z walidacją względem pliku XSD.

Wymagane dependency:
        <dependency>
            <groupId>org.apache.camel</groupId>
            <artifactId>camel-jaxb</artifactId>
            <version>${camel-version}</version>
        </dependency>

//W serwisie dodajemy metodę do uruchomienia pobierania danych z XML:
    public void getBookXML() {
        log.info("Import z XML BEGIN");   
        BookXML bookXML = null;
        Exchange exchFile;
        List<BookDTO> books = new ArrayList<BookDTO>();
        ProducerTemplate producer = camelContext.createProducerTemplate();
        ConsumerTemplate consumer = camelContext.createConsumerTemplate();
        try {
            String endpoint = MyUtils.getParameterOrNull("endpoint.file");
            log.info("endpoint: "+endpoint);
            exchFile = consumer.receive(endpoint, 2000L);
            if (exchFile != null && exchFile.getIn() != null
                    && exchFile.getIn().getBody() != null) {
                log.info("Pobrano z: "
                        + exchFile.getIn().getBody().getClass().toString());
                log.info("ret: " + exchFile.getIn().getBody().toString());

               
                Object validRet = producer.sendBody("direct:unmarshal",
                        ExchangePattern.InOut, exchFile.getIn().getBody());
                if(validRet instanceof Boolean
                        && (Boolean)validRet){
                    bookXML = (BookXML) producer.sendBody("direct:readXmlBook",
                            ExchangePattern.InOut, exchFile.getIn().getBody());
                }else{
                    throw new MyException("B\u0142\u0105d walidacji XML");
                }               
                books = prepareHashMapBooks(bookXML);
                consumer.doneUoW(exchFile);
            } else {
                log.info("Brak pliku do importu");
            }
            log.info("Pobrano: "+books.size());
        } catch (Exception e) {
            e.printStackTrace();
        }   
        log.info("Import z XML END");
    }

//BUILDER TRAS APACHE CAMEL
import org.apache.camel.builder.RouteBuilder;
import org.apache.camel.model.dataformat.JaxbDataFormat;

public class MyRouteBuilderFile extends RouteBuilder{

    @Override
    public void configure() throws Exception {       
        JaxbDataFormat dataFormat = new JaxbDataFormat(false);
        dataFormat.setContextPath("com.bloger.programmingmt.example");
        //przeksztalcenie na z XML na DTO
        from("direct:unmarshalFile")
        .unmarshal(dataFormat)
        .to("log: IN ==>");

        //Parsowania XML na podstawie XSD
        from("direct:unmarshal")
        .convertBodyTo(org.w3c.dom.Document.class)
        .bean(ParserXMLFileProcessor .class, "process")
        .end();
    }

}

//PROCESOR WALIDUJACY STRUKTURE PLIKU XML NA PODSTAWIE XSD
public class ParserXMLFileProcessor implements Processor {
   
    private static final Logger log = Logger.getLogger(ParserXMLFileProcessor.class);
   
    @Autowired
    private CamelContext camelContext;

   
    @Override
    public void process(Exchange exchange) throws Exception {
        Exchange exchFile = null;
        try {
            SchemaFactory factory = SchemaFactory
                    .newInstance(XMLConstants.W3C_XML_SCHEMA_NS_URI);
           
            ConsumerTemplate consumer = camelContext.createConsumerTemplate();
            //Wskazanie pliku XSD do walidacji
            String schemaFileEndpoint = Utils.getParameterOrNull("endpoint.book.file.validator");
            log.info("schemaFileEndpoint: "+schemaFileEndpoint);
            try {
                if(schemaFileEndpoint!=null
                        && schemaFileEndpoint.length()>0){
                exchFile = consumer.receive(schemaFileEndpoint, 2000L);
                }
            } catch (Exception e) {
                e.printStackTrace();
                throw new MyException("Wystąpił wyjątek podczas pobierania pliku XSD dla walidacji: "+e.getMessage());
            }
            if (exchFile != null && exchFile.getIn() != null
                    && exchFile.getIn().getBody() != null) {
                log.info("Pobrano z: "
                        + exchFile.getIn().getBody().getClass().toString());
                log.info("ret: " + exchFile.getIn().getBody().toString());
                Schema schema = factory.newSchema((File)((GenericFile)exchFile.getIn().getBody()).getFile());
   
                Validator validator = schema.newValidator();
                validator.validate(new DOMSource((Document)exchange.getIn().getBody()));
                System.out.println("...passed...");
                consumer.doneUoW(exchFile);
            } else {
                log.info("Brak pliku do walidacji struktury");
            }
            exchange.getIn().setBody(Boolean.TRUE);
            exchange.getOut().setBody(Boolean.TRUE);
        } catch (Exception e) {
            e.printStackTrace();
            exchange.getIn().setBody(Boolean.FALSE);
            exchange.getOut().setBody(Boolean.FALSE);
        }
    }
   
    public void setCamelContext(
            CamelContext camelContext) {
        this.camelContext = camelContext;
    }
}

JAVA - kopiowanie obiektów

Przed kopiowaniem/klonowaniem obiektu należy zastanowić się czy chcemy uzyskać kopię wraz z referencją czy nie.


1) Kopiowanie z referencją:

public class MyDTO implements Cloneable{

    public MyDTO(){
    }

 
    ... 

    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

2) Kopiowanie bez referencji:
 Najprostszym sposobem jest wykorzystanie klasy 'org.apache.commons.lang.SerializationUtils'
       MyDTO newMyDTO= (MyDTO )SerializationUtils.clone(oldMyDTO);

JNDI / iBatis - konfiguracja połączenie do bazy danych

[Jboss, Oracle, iBatis]

Połączenie do bazy danych można skonfigurować w samej aplikacji podając odpowiednie parametry. Można również podpiąć się do połączenia skonfigurowanego na Jboss.

Drugi sposób wydaje się być lepszy z powodu większej elastyczności.
Poniższy przykład ma jedynie pokazywać jak wszystko spiąć - zdaję sobie sprawę iż zawiera pewne niedociągnięcia :)

Połączenie do Oracle skonfigurowane na Jboss:

Plik konfiguracyjny: JBoss\server\default\deploy\MyApp-ds.xml:
   <datasources>
   <local-tx-datasource>
   <jndi-name>MyAppDS</jndi-name>
   <connection-url>jdbc:oracle:thin:@localhost:1521:myapp</connection-url>
   <driver-class>oracle.jdbc.OracleDriver</driver-class>
   <user-name>myapp</user-name>
   <password>myapp</password>
   <min-pool-size>0</min-pool-size>
   <exception-sorter-class-name>org.jboss.resource.adapter.jdbc.vendor.OracleExceptionSorter</exception-sorter-class-name>
   </local-tx-datasource>
   </datasources>

Konfiguracja spring:
    <bean id="myAppDataBase" class="org.springframework.jndi.JndiObjectFactoryBean">
        <property name="jndiName"><value>java:MyAppDS</value></property>
    </bean>

Połączenie do Oracle skonfigurowane wewnątrz aplikacji:

Konfiguracja spring:
     <bean id="myAppDataBase" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
        <property name="driverClassName" value="oracle.jdbc.OracleDriver" />
        <property name="url" value="jdbc:oracle:thin:@localhost:1521:myapp" />
        <property name="username" value="myapp" />
        <property name="password" value="myapp" />       
    </bean>

Część wspólna konfiguracji:

Konfiguracja spring: 
    <bean class="org.springframework.orm.ibatis.SqlMapClientFactoryBean"
        id="myAppSqlClient">
        <property name="configLocation" value="classpath:/spring/ibatis/sqlMapConfigMyApp.xml" />
        <property name="dataSource" ref="myAppDataBase"/>
    </bean>

    <bean class="org.springframework.orm.ibatis.SqlMapClientTemplate"
        id="myAppSqlMapClientTemplate">
        <property name="sqlMapClient" ref="myAppSqlClient" />
    </bean>

    <bean class="com.blogger.programmingmt.myapp.dao.MyAppDAO"
        id="myappDAO">
        <property name="sqlMapClientTemplate" ref="myAppSqlMapClientTemplate" />
    </bean> 

sqlMapConfigMyApp.xml:
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE sqlMapConfig PUBLIC "-//iBATIS.com//DTD SQL Map Config 2.0//EN" "http://www.ibatis.com/dtd/sql-map-config-2.dtd">
<sqlMapConfig>
    <sqlMap resource="spring/ibatis/sqlmaps/myApp.xml"/>
</sqlMapConfig>

myApp.xml:
<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<!DOCTYPE sqlMap PUBLIC "-//ibatis.apache.org//DTD SQL Map 2.0//EN" "http://ibatis.apache.org/dtd/sql-map-2.dtd">
<sqlMap namespace="MyApp">

    <resultMap class="com.blogger.programmingmt.myapp.dto.MyTestDTO"
        id="MyTestResultMap">
        <result column="ID" property="id" />
        <result column="IMIE" property="imie" />
        <result column="NAZWISKO" property="nazwisko" />
    </resultMap>

    <select id="findMyTestDTO" resultMap="MyTestResultMap">
    <![CDATA[
      select
          ID    as    ID
      ,    IMIE    as    IMIE
      ,    NAZWISKO    as    NAZWISKO
      from MyApp
    ]]>
    </select>
   
    <update id="updateMyTestDTO" parameterClass="com.blogger.programmingmt.myapp.dto.MyTestDTO">
    <![CDATA[
    update MyApp set
      IMIE = #imie#
    where
      ID = #id#
    ]]>
    </update>
</sqlMap>

Definicja DAO:
public class MyAppDAO extends SqlMapClientDaoSupport {
   
    @SuppressWarnings("unchecked")
    public List<MyTestDTO> findMyTestDTO() throws SQLException{
        return (List<MyTestDTO>) getSqlMapClient().queryForList("findMyTestDTO");
    }
   
    public int updateMyTestDTO(MyTestDTO toUpdate) throws SQLException{
        return getSqlMapClient().update("updateMyTestDTO",toUpdate);
    }

}

Java - polskie znaki

Polskie znaki:

# ą - \u0105
# ć - \u0107
# ę - \u0119
# ł - \u0142
# ń - \u0144
# ó - \u00f3
# ś - \u015b
# ź - \u017a
# ż - \u017c