Java Persistence Api (JPA) jest wykorzystywane do mapowania encji zapisanych w bazie danych (wiersze tabeli) na ich obiektową reprezentację również nazywaną encją. Zbieżność terminów może powodować konsternację dlatego w dalszej części wpisu przez pojęcie encja należy rozumieć tylko odpowiednio opisaną klasę w języku Java.
W ogólnym wypadku każda klasa spełniająca wymogi JavaBean tj. posiadająca bezparametrowy konstruktor oraz metody get i set dla pól może zostać przekształcona w encję. Dla przykładu, Grupa może zostać opisana przez taki komponent:

package eu.doniec.piotr.bean

public class Grupa {
    private Long id;

    private String nazwa;
    private String opis;

    public Long getId() { return id; }
    public void setId(Long id) { this.id = id; }
    public String getNazwa() { return nazwa; }
    public void setNazwa(String nazwa) { this.nazwa = nazwa; }
    public String getOpis() { return opis; }
    public void setOpis(String opis) { this.opis = opis; }
}

Modyfikacja do postaci encji, możliwej do wykorzystania przez JPA do obsługi danych zawartych w tabeli Grupy polega na opisaniu klasy metainformacjami – adnotacjami z pakietu javax.persistence. Gotowa klasa przedstawia się następująco:

package eu.doniec.piotr.persistence;

import java.io.Serializable;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.NamedQuery;
import javax.persistence.Table;

@Entity
@NamedQuery(
    name="findAllGroups",
    query="SELECT g FROM Grupa g"
)
@Table(name="GRUPY")
public class Grupa implements Serializable {

    @Id @GeneratedValue(strategy = GenerationType.AUTO)
    private Long id;

    private String nazwa;
    private String opis;

    public Long getId() { return id; }
    public void setId(Long id) { this.id = id; }
    public String getNazwa() { return nazwa; }
    public void setNazwa(String nazwa) { this.nazwa = nazwa; }
    public String getOpis() { return opis; }
    public void setOpis(String opis) { this.opis = opis; }
}

Podobnie sytuacja wygląda z klasą Studenta, choć tu sytuacja jest trochę inna. Struktura bazy danych wymaga aby tabela STUDENCI posiadała ograniczenie FOREIGN_KEY na dodatkowe pole GRUPA_ID. W takiej sytuacji w ramach encji Student umieszczamy odwołanie do encji Grupa. Właściwość ta jest dodatkowo oznaczona adnotacją @ManyToOne oznaczającą właśnie że wielu studentów może przynależeć do jednej grupy.

package eu.doniec.piotr.persistence;

import java.io.Serializable;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

import javax.persistence.NamedQuery;
import javax.persistence.Table;
import javax.persistence.ManyToOne;
import javax.persistence.JoinColumn;

@Entity
@NamedQuery(
    name="findAllStudents",
    query="SELECT s FROM Student s"
)
@Table(name="STUDENCI")
public class Student implements Serializable {
    @Id @GeneratedValue(strategy = GenerationType.AUTO)
    private Long nr_indeksu;

    private String imie;
    private String nazwisko;

    @ManyToOne
    private Grupa grupa;

    public Long getNr_indeksu() { return nr_indeksu; }
    public void setNr_indeksu(Long nr_indeksu) { this.nr_indeksu=nr_indeksu; }
    public String getImie() { return imie; }
    public void setImie(String imie) { this.imie = imie; }
    public String getNazwisko() { return nazwisko; }
    public void setNazwisko(String nazwisko) { this.nazwisko = nazwisko; }
    public Grupa getGrupa() { return grupa; }
    public void setGrupa(Grupa grupa) { this.grupa = grupa; }
}

Encje są zdefiniowane, pozostało jeszcze je wykorzystać. W tym celu powstanie servlet, który wyświetli nr indeksu, nazwisk i przydział studenta do grupy. W celu wykorzystania stworzonych obiektów trzeba utworzyć obiekt EntityManager’a, a raczej “wstrzyknąć” go do aplikacji – uzyskuje się to annotacją @PersistenceContext. Utworzony w ten sposób EntityManager jest zarządzany przez kontener aplikacji tzw. container-managed. Sensowne wydaje się wstrzyknięcie go w klasie implementującej ServletContextListener i zapisanie w kontekście servletu, w ten sposób łatwo będzie się do niego dostać:

package eu.doniec.piotr.listeners;

import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;
import javax.servlet.annotation.WebListener;
import javax.servlet.ServletContext;

import javax.persistence.PersistenceContext;
import javax.persistence.EntityManager;

@WebListener()
public class ContextListener implements ServletContextListener {

    @PersistenceContext
    private EntityManager em;

    private ServletContext context;

    public void contextInitialized(ServletContextEvent sce) {
        context = sce.getServletContext();
        context.setAttribute("EntityManager", em);
    }

    public void contextDestroyed(ServletContextEvent sce) {
        context.removeAttribute("EntityManager");
    }
}

Na tym etapie, pozostało już tylko stworzenie serwletu i konfiguracja połączenia z bazą danych. Ostatni, prymitywny fragment kodu wypisuje na ekran nr indeksu, nazwisko i nazwę grupy do której zapisany jest student.

package eu.doniec.piotr.servlets;

import eu.doniec.piotr.persistence.Student;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.Iterator;
import java.util.List;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import javax.persistence.EntityManager;
import javax.persistence.Query;

@WebServlet(name="studenci", urlPatterns={"/studenci"})
public class Studenci extends HttpServlet {

    protected void processRequest(HttpServletRequest request, HttpServletResponse response)
    throws ServletException, IOException {
        response.setContentType("text/html;charset=UTF-8");
        PrintWriter out = response.getWriter();
        try {
            EntityManager em = (EntityManager)getServletContext().getAttribute("EntityManager");
            Query q = em.createNamedQuery("findAllStudents");

            out.println("<html>");
            out.println("<head>");
            out.println("<title>Servlet studenci</title>");
            out.println("</head>");
            out.println("<body>");
            out.println("<h1>Servlet studenci at " + request.getContextPath () + "</h1>");

            out.println("<table>");
            out.println("<tr><th>Numer indeksu</th><th>Nazwisko</th><th>Grupa</th></tr>");

            List studenci =  q.getResultList();
            for (Iterator iter = studenci.iterator(); iter.hasNext();) {
                Student s = (Student) iter.next();
                out.println("<tr>");
                out.println("<td>" + s.getNr_indeksu() +"</td>");
                out.println("<td>" + s.getNazwisko() + "</td>");
                out.println("<td>" + s.getGrupa().getNazwa() +"</td>");
                out.println("</tr>");
            }

            out.println("</body>");
            out.println("</html>");
        } finally {
            out.close();
        }
    } 

    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response)
    throws ServletException, IOException {
        processRequest(request, response);
    }
}

Plik persistence.xml:

<?xml version="1.0" encoding="UTF-8"?>
<persistence version="1.0" 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_1_0.xsd">
  <persistence-unit name="baza-danych-nauczyciela-pu" transaction-type="JTA">
    <provider>oracle.toplink.essentials.PersistenceProvider</provider>
    <jta-data-source>jdbc/bazanauczyciela</jta-data-source>
  </persistence-unit>
</persistence>

Sposób stworzenie źródła danych dla Oracle pod Glassfish wystarczająco dobrze opisany jest tu: http://technology.amis.nl/blog/1276/configuring-a-oracle-datasource-on-glassfish.

Program('main.cpp')

Na Windows domyślnie zostanie wykorzystany (o ile dostępny) kompilator Microsoftu. Jeśli jednak chcemy użyć g++, wystarczy dopisać jeszcze jedną linię:

env = Environment(tools = ['mingw'], CC = 'gcc', CCFLAGS = '-O2')
env.Program('main.cpp')

Piewsze lody przełamane, kolejne próby będą sprawdzały łatwość dołączania zewnętrzych bibliotek jak boost czy qt.

Na wszelki, skopiowany kod poprawki poniżej:

— ZSI-2.1-a1/ZSI/ServiceContainer.py 2007-08-08 00:56:37.000000000 +0200
+++ ServiceContainer.py 2008-06-19 13:50:11.000000000 +0200
@@ -5,6 +5,7 @@

import urlparse, types, os, sys, cStringIO as StringIO, thread,re
from BaseHTTPServer import BaseHTTPRequestHandler, HTTPServer
+from SocketServer import ThreadingMixIn
from ZSI import ParseException, FaultFromException,
FaultFromZSIException, Fault
from ZSI import _copyright, _seqtypes, _get_element_nsuri_name, resolvers
from ZSI import _get_idstr
@@ -30,6 +31,7 @@
SimpleWSResource
SOAPRequestHandler
ServiceContainer
+ ThreadedServiceContainer
“”"
class NoSuchService(Exception): pass
class UnknownRequestException(Exception): pass
@@ -141,12 +143,16 @@
return SendFault(FaultFromException(e, 0, sys.exc_info()[2]), **kw)

-def AsServer(port=80, services=()):
+def AsServer(port=80, services=(), threaded=False):
”’port –
services — list of service instances
+ threaded — in modo multithread ?
”’
address = (”, port)
- sc = ServiceContainer(address, services)
+ if threaded:
+ sc = ThreadedServiceContainer(address, services)
+ else:
+ sc = ServiceContainer(address, services)
sc.serve_forever()

@@ -467,6 +473,11 @@
def removeNode(self, url):
self._nodes.removeNode(url)

+class ThreadedServiceContainer(ThreadingMixIn, ServiceContainer):
+ ”’Multithreaded version of ServiceContainer.
+ ”’
+ pass
+

class SimpleWSResource(ServiceSOAPBinding):

# gry - lista skladajaca sie z list reprezentujacych gre. Kazda reprezentacja
# gry to kolejna lista zaiwerajaca ilosc 'kijkow' na kolejnych stosach
def graj(gry):
    sg = (0, 0, 1, 1, 2, 2, 3)
    for gra in gry:
        g = []
        reszty = []
        for stos in gra:
            reszta = int(stos)%7
            g.append(sg[reszta])
            reszty.append(reszta)
        wynik = reduce(lambda x,y: x^y, g)

        if wynik :
            print "Julia wins."
        else :
            print "Robert wins.\n"

Lekki problem pojawia się przy ustalaniu ruchu wygrywającego. Nie wiem czy istnieje jakieś szybsze rozwiązanie niż takie trochę brute-force’owe która ja wykorzystałem. Polega ono na stwierdzeniu na jakiej pozycji ( wygrywającej czy przegrywającej ) znalazł by się gracz gdyby nie było jednego stosiku, a następnie obliczeniu czy da się odjąć taką liczbę patyczków żeby zostawić przeciwnika na pozycji przegrywającej.
Dodatkowo oprócz wskazania ruchu wygrywającego należy wskazać ten podczas którego bierze się najwięcej patyczków ze stosu o najmniejszym numerze, co w lekki sposób komplikuje sprawę.:

        stos_wygrywajacy = 0;
        licznik = 0
        blokada_5 = False
        blokada_3 = False

        # odwrocenie list, sprawdzanie od konca
        gra_rev = gra[:]
        gra_rev.reverse()

        g_rev = g[:]
        g_rev.reverse()

        reszty.reverse()
        for reszta in reszty:
            # lista reszt bez kolejnych stosow
            tmpr = reszty[:]
            tmpr.pop(licznik)

            # xor wartosci f. Sprague-Grundy'ego
            # bez kolejnych stosow
            tmpg = g_rev[:]
            tmpg.pop(licznik)
            tmpw = reduce(lambda x,y: x^y, tmpg ,0)

            if sg[reszta-5] == tmpw and int(gra_rev[licznik]) >= 5:
                wygrywajacy = 5
                stos_wygrywajacy = len(reszty) - licznik
                blokada_5 = True
            elif sg[reszta-3] == tmpw and int(gra_rev[licznik]) >= 3 and blokada_5 == False:
                wygrywajacy = 3
                stos_wygrywajacy = len(reszty) - licznik
                blokada_3 = True
            elif sg[reszta-2] == tmpw and int(gra_rev[licznik]) >= 2 and blokada_5 == False and blokada_3 == False:
                wygrywajacy = 2
                stos_wygrywajacy = len(reszty) - licznik

            licznik += 1

Jeśli ktoś zna szybsze rozwiązanie chętnie je przeanalizuję
Zaznaczam, że nie dam sobie głowy uciąć że algorytm jest poprawny, bo nie ma już możliwości zgłoszenia rozwiązania – upłynęły terminy.

EDIT:
Lekko poprawiona wersja, działa trochę szybciej, natomiast i tak nie umożliwia zdobycia maximum punktów. Jesli nie ma jakiejś sztuczki na ruch wygrywający, a podejrzewam że coś jest, to lepiej zakodzić to w C…

        stos_wygrywajacy = 0
        blokada_3 = False
        blokada_2 = False
        licznik = 0
        for reszta in reszty :
            tmpg = g[:]
            tmpg.pop(licznik)
            tmpw = reduce(lambda x,y: x^y, tmpg, 0)

            if sg[reszta-5] == tmpw and int(gra[licznik]) >= 5:
                wygrywajacy = 5
                stos_wygrywajacy = licznik + 1
                break
            elif sg[reszta-3] == tmpw and int(gra[licznik]) >= 3 and blokada_3 == False:
                wygrywajacy = 3
                stos_wygrywajacy = licznik + 1
                blokada_3 = True
            elif sg[reszta-2] == tmpw and int(gra[licznik]) >= 2 and blokada_3 == False and blokada_2 == False:
                wygrywajacy = 2
                stos_wygrywajacy = licznik + 1
                blokada_2 = True
            licznik += 1

Poniższy film przedstawia jak z pomocą NetBeans 6.8 poprawnie zbudować projekt i zdeployować go na serwerze aplikacji. W moim przypadku serwerem aplikacji jest Glassfish v3.

Na deploy’u jednak nie koniecznie musi się skończyć. Wiele przykładów do SDK 5 wymaga połączenia z bazą danych. Tak jest z aplikacją bookstore, wykorzystaną w poprzednim filmie. Mimo że została poprawnie umieszczona na serwerze, nie może pobrać danych, o czym informuje zgłoszony wyjątek. Konfiguracja bazy oraz połączenia

Jej to moje pierwsze screencasty

Aby istniała możliwość ustawiania przezroczystości dla okna, musi być ono utworzone w sposób do tego przystosowany. Wystarczy skorzystać z innej funkcji tworzącej okno, nie CreateWindow, a CreateWindowEx

To co umożliwia później modyfikacje przezroczystości jest ukryte w ramach dodatkowego stylu okna, podawanego poprzez argument dwExStyle. Lista dopuszczalnych wartości jest długa, ale warto się z nią zapoznać. W tym konkretnym przypadku należy zainteresować się wartością WS_EX_LAYERED, utworzone wtedy okno będzie tzw. Layered Window, które obsługuje modyfikacje przezroczystości. Do ustawienia nowej wartości kanału alpha służy SetLayeredWindowAttributes(HWND hwnd, COLORREF crKey, BYTE bAlpha, DWROD dwFlags) – szczegóły w dokumentacji.
Pełny kod tworzący przykładowe, półprzezroczyste okno:

To co należy zrobić, aby kontrolować przezroczystość okien innych niż własne przedstawia się następująco:

1. 1. Pobrać wszystkie otwarte okna typu top-level
2. 2. Nadać oknom styl dwExStyle
3. 3. Zmienić wartość kanału alpha

1. Pobrać wszystkie otwarte okna typu top-level
Dobrym pomysłem wydaje się pobranie uchwytu do rodzica wszystkich okien(Desktop/Pulpit) i przejście w pętli po liście jego dzieci (jak wiadomo każde okno ma kilka przydatnych wskaźników, między innymi do okna-brata). Mogłoby to wyglądać tak:

Pomysł zły ! Okazuje się że taka pętla może działać w nieskończoność. Wzmianaka na temat takiego przypadku znajduje się nawet w dokumentacji. Dlatego należy wykorzystać inny sposób, polegający na użyciu funkcji BOOL EnumWindows(WNDENUMPROC lpEnumFunc, LPARAM lParam):

2. Nadać oknom styl dwExStyle
Wydaje się najtrudniejsze, przecież dodatkowy styl należy podać przy tworzeniu okna, a okna które widzimy zostały już przecież utworzone. Na szczęście z pomocą przychodzi funkcja LONG SetWindowLong(HWND hWnd, int iIndex, LONG dwNewLong):

3. Zmienić wartość kanału alpha
Bardziej uważni czytelnicy już na pewno wiedzą jak wygląda zestaw parametrów i jak skorzystać z SetLayeredWindowAttributes. Wykorzystanie pokazane 3 listingi wyżej, przy okazji tworzenia “własnego” przezroczystego okna.

I to tyle tym temacie, wypada jeszcze stworzyć GUI, może obsługę tray’a. Program wydaje się “magiczny” a korzysta raptem z 4 funkcji API systemowego.

# Unload drivers
#shutdown_dynamic
#echo -n “Unloading DAHDI hardware modules: ”
#if unload_module dahdi; then
# echo “done”
#else
# echo “error”
#fi
#if [ "$LOCKFILE" != '' ]; then
# [ $RETVAL -eq 0 ] && rm -f $LOCKFILE
#fi

i zamykanie systemu zaczyna działać jak należy. Może sam problem nie jest zbyt uciążliwy gdyż działający serwer VoIP nie jest często resetowany. Ale zabawa zaczyna się gdy zaistnieje potrzeba przeprowadzenia takiej operacji zdalnie…

Może dziwić ale zbudowanie okna korzystając z języka maszynowego nie jest trudno. Objętość programu jest zbliżona do tego utworzonego standardowo z wykorzystaniem C. Ponadto korzystając z kompilatora dostarczonego przez Microsoft (MASM) istnieje możliwość bardzo łatwego dostępu do funkcji API systemu Windows. Ponad to kompilator dostarcza wiele ułatwiających życie makr.

Nie ma co wiele tłumaczyć. Kod jaki jest interpretowany przez MASM wygląda już niemalże jak język wysokiego poziomu(niektórzy mówią że C to język niskiego poziomu, ale to dlatego że nie umieli znaleźć określenia dla Javy, C# itp.) Bardzo fajnym makrem jest invoke uruchamiające zadaną procedurę i umożliwiające podanie listy argumentów poprzez rozdzielenie przecinkiem. Bardzo przyjemna alternatywa dla push’owania w odwrotnej kolejności.
Jedyny wniosek jaki można wysnuć to to że jeżeli ktoś umie programować z wykorzystaniem WinAPI w C, to i bez problemu zastosuje go w assemblerze. Oczywiście nie ma obowiązku korzystania z MASM, do API można się także dostać korzystać z innych assemblerów np. NASM ( polacam zapoznanie się z nasmx).

package foo;

public class Licznik {
    private static int liczba;
    public static synchronized int getLiczba() {
        liczba++;
        return liczba;
    }
}

to kod wstawiony do strony JSP korzystający z licznika powinien wyglądać następująco:
<% out.println(foo.licznik.getLiczba()); %>

Oprócz znacznika skryptletu który został przed chwilą zaprezentowane w stronach JSP można spotkać również inne, np.

• Dyrektywa: <%@ ... %>, np: <%@page contentType="text/html; charset=UTF-8" %> ustawia typ treści
• Wyrażenie <%= ... %>, np. <%= Licznik.getLiczba() %> spowoduje wyświetlenie aktualnego stanu licznika.
• Definicja: <%! ... %>, umożliwia definiowanie zmiennych i metod które są później “wstrzykiwane” do tworzonej klasy servletu. W ramach tych znaczników jesteśmy upoważnieni do przeciążenia metod jspInit oraz jspDestroy które są wywoływane odpowiednio przy powoływaniu servletu do życia i przy jego usuwaniuz kontenera. Z uwagi na fakt że definicje metod zawartych w obrębie znacznika defincji stają metodami servletu, nie ma tu dostępu do zmienny request i response

Jak wspomniałem każda strona JSP jest servletem. Strona jest tłumaczona przez kontener na odpowiedni servlet. Wykorzystanie różnych znaczników do zaprezentowania innego typu zawartości ułatwia kontenerowi konwersję. I tak dyrektywy są używane aby kontrolować jak kontener ma przetłumaczyć a następnie wykonać kod strony, skryptlety są po prostu przepisywane do kodu servletu natomiast wyrażenia są przekazywane jako parametry odpowiednich funkcji.