Detta avtal befäster Cygnis ställning som en ledande leverantör av konsulttjänster till företag vars webbtjänster har exceptionella krav på prestanda, säkerhet och användbarhet.

Det finns redan mängder med tutorials över hur man sätter upp Google-konton på sin iPhone men jag har upplevt det aningen problematiskt att synka multipla Google-kalendrar och tänker mig att detta inlägg får fungera som en steg för steg-guide över hur jag fick till synkningen. Jag har en iPhone 3GS med iOS 5 och använder mig av Google Sync för synkronisering.

Har du inte redan satt upp ett Google-konto på din iPhone följer du dessa steg:

1. Under inställningsmenyn på din iPhone väljer du E-post, kontakter, kalendrar
2. Lägg till konto
3. Välj att skapa ett Microsoft Exchange-konto (vilket är det protokoll Google Sync använder vid synkronisering till iPhone)

4. Under E-post fyller du i din fullständiga e-postadress
5. Lämna domänfältet tomt
6. Fyll i din fullständiga e-postadress under Användarnamn
7. Skriv in lösenordet för ditt Google-konto
8. Klicka på Nästa
9. När fältet Server poppar upp fyller du i m.google.com
10. Klicka på Nästa
11. Välj vad du vill synka (denna guide kräver att du åtminstone väljer att synka kalendrar)

Setup av synkroniseringen är nu klar och beroende på vad du i steg 11 valde att synka kommer det nu att pushas ut information till din iPhone.

Med Google Sync kan du synka upp till 25 kalendrar på din iPhone vilket man enkelt ska kunna sätta upp genom att surfa in på http://m.google.com/sync och logga in på sitt konto. Här stötte jag dock på problem. Sidan talade om för mig att Google Sync tyvärr inte kunde stödja min enhet eftersom jag var tvungen att ha iOS 3 eller senare – något som jag uppenbarligen hade då jag precis uppdaterat till iOS 5.

Efter en tids undersökning kunde jag konstatera att detta var en bugg fler användare upplevt och en konsekvens av att Google Sync befinner sig i ett beta-stadie. Sajten kräver att sidan presenteras på engelska och det du behöver göra för att komma runt problemet är att byta språk från svenska till just engelska enligt nedan steg:

12. Med din iPhone, surfa in på http://m.google.com/sync
13. För att ändra språk klickar du på länken Byt språk (jag valde English (UK))
14. Sidan laddas om och du har nu möjlighet att logga in. Gör detta genom att klicka på Sign in with your Google Account
15. Du möts nu av de enheter du har satt upp ditt Google-konto på och genom att klicka dig in på de olika enheterna kan du välja exakt vilka kalendrar du vill synka

16. Efter att ha valt vilka kalendrar du vill synka och klickat på Save är du klar

När du nu lägger till, editerar eller tar bort händelser i dina kalendrar kommer dessa speglas på alla enheter du synkat enligt ovan steg – detta gäller självfallet oberoende av om du gör förändringarna i kalendern på din iPhone eller i webbgränssnittet på din dator.

Cygni har de senaste åren framgångsrikt levererat konsulttjänster till majoriteten av de största svenska mediebolagen. Det nya avtalet med Svenska Dagbladet är ytterligare ett i raden av bevis för att Cygnis spetskompetens är efterfrågad i mediebranschen.

package se.cygni.blog;

import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;

import javax.persistence.EntityManager;

import org.junit.Before;
import org.junit.Test;

public class BlogServiceTest {

    private BlogService service;
    private EntityManager entityManager;

    @Before
    public void setup() {
        entityManager = mock(EntityManager.class);
        service = new BlogService(entityManager);
    }

    @Test
    public void addEntry() {
        Entry entry = new Entry("title", "text");

        service.addEntry(entry);

        verify(entityManager).persist(entry);
    }

}

Testet i exemplet är relativt enkelt och verifierar endast att persist anropas i addEntry och ger oss följande kod för ett Spring-baserat projekt:

package se.cygni.blog;

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

import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
public class BlogService {

    @PersistenceContext
    private EntityManager entityManager;

    public BlogService() {
    }

    protected BlogService(EntityManager entityManager) {
        this.entityManager = entityManager;
    }

    @Transactional
    public void addEntry(Entry entry) {
        entityManager.persist(entry);
    }

}

För att kunna använda en mockad entityManager har vi lagt till en konstruktor som tar en EntityManager som BlogService sedan kan använda. Använder vi dessutom ”field injection” är vi tvugna att lägga till en no-args-konstruktor. Alternativt hade vi kunnat lägga till en setter istället.

    protected void setEntityManager(EntityManager entityManager) {
        this.entityManager = entityManager;
    }

Det är väl antagligen inte så illa att behöva lägga till konstruktorer alternativt setters även om det blir värre när en klass har flera beroenden. Däremot känns det ju lite onödigt när både Spring och Java EE numera stödjer field injection. Det går ju att köra enhetstesterna med till exempel Spring och låta Spring injicera alla beroenden. Detta anses dock inte helt lämpligt för enhetstester utan lämpar sig bättre för integrationstester. Istället kan Mockito ta hand om injicering, genom att köra testerna med MockitoJUnitRunner och använda annotationerna @Mock och @InjectMocks. Mockito fungerar då i princip som en enkel IOC-container och några extra konstruktorer eller setters behövs inte.

package se.cygni.blog;

import static org.mockito.Mockito.verify;

import javax.persistence.EntityManager;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.runners.MockitoJUnitRunner;

@RunWith(MockitoJUnitRunner.class)
public class BlogServiceTest {

    @Mock
    private EntityManager entityManager;

    @InjectMocks
    private BlogService service = new BlogService();

    @Test
    public void addEntry() {
        Entry entry = new Entry("title", "text");

        service.addEntry(entry);

        verify(entityManager).persist(entry);
    }
}

Det är främst ett par enheter på Sveriges Television som har det största konsultbehovet framöver – ’SVT Teknik och Utveckling’ och ’SVT Interaktiv’. Inom ’SVT Teknik och Utveckling’ är det i huvudsak webbapplikationer och integrationer mellan system för broadcast och administrativa system som skall utvecklas. ’SVT Interaktiv’ utvecklar och samordnar utbudet av interaktiva tjänster mot publiken.

”Sättet som vi konsumerar TV på är i snabb förändring med mobila plattformar, interaktivitet och ett icke-linjärt utbud. Sveriges Television leder denna utveckling på många fronter. Att Cygni nu får möjlighet att delta i det arbetet är väldigt stimulerande, både för oss som företag och för våra konsulter” säger Jon Persson, VD på Cygni.

Cygni är ett IT-konsultbolag som erbjuder expertis inom agil systemutveckling på moderna plattformar. Under de senaste 5 åren har Cygni framgångsrikt levererat systemarkitekter, Scrum Masters, backendutvecklare och frontendutvecklare till flera av Sveriges ledande mediabolag.

”Detta ramavtal ger Cygni möjlighet att leverera avancerade konsulttjänster till några av Sveriges mest spännande utvecklingsorganisationer. Vi är mycket stolta och glada över det förtroende som Sveriges Television gett oss.” avslutar Jon Persson.

@Controller
public class MyController {

    @EJB(mappedName="java:module/MyService")
    private MyService myService;

    @RequestMapping(value = "/", method = RequestMethod.GET)
    public String home(Model model) {
        model.addAttribute("message", myService.getMessage());
        return "home";
    }
}

Nyckeln till att injektionen med @EJB-annotation fungerar, i exemplet ovan, är att mappedName används. Spring utför då en JNDI-lookup på det angivna JNDI-namnet. Eftersom JNDI har standardiserats i Java EE 6 är dessutom namnen portabla mellan applikationsservrar. Stödet för Java EE 6 kommer säkerligen förbättras i framtida versioner av Spring så det finns bra defaults för ejb-lookups med JNDI.

En annan spännande detalj med detta exempel är att MyService inte behöver vara ett interface eftersom Java EE 6 inte kräver detta för lokala session beans. Dessutom kan session beans paketeras tillsammans med resten av webbapplikationen i war-arkivet. D.v.s. det behövs ingen ejb-jar och inget EAR-arkiv.

Läs hela artikeln på Java Code Geeks.

• Roberts inlägg om kortkommandon och handgrepp är alltid högaktuellt. Inlägget visar bland annat på smarta kommandon för navigering och refactoring.
• Save Actions är ett ovärderligt verktyg om du vill hålla ordning och reda i koden.
• Conditional Breakpoints och Exception Breakpoints kan vara välbehövligt i vissa debugsituationer.

Kolla även in en rad tips på olika smarta plugins, hur man remote-debuggar osv.

@NotNull
@Size(min = 5, max = 20)
@Pattern(regexp = "[a-zA-Z0-9\\._-]+")
private String userName;

Bean Validation är inte knutet till något speciellt ramverk eller lager. Det finns däremot bra stöd för Bean Validation i flertalet populära ramverk, såsom Hibernate och JSF 2. Dessutom är det enkelt att utföra validering via API:t:

import javax.validation.ConstraintViolation;
import javax.validation.Validation;
import javax.validation.Validator;
import javax.validation.ValidatorFactory;
...
ValidatorFactory factory = Validation.buildDefaultValidatorFactory();
Validator validator = factory.getValidator();
Set<ConstraintViolation<Customer>> constraintViolations = validator.validate(customer);

För att komma igång med ett Bean Validation (Hibernate Validator 4.x är referensimplementationen) i ett Maven-projekt lägg till följande beroenden i din pom:

<dependency>
 <groupId>org.hibernate</groupId>
 <artifactId>hibernate-validator</artifactId>
 <version>4.2.0.Final</version>
</dependency>
<dependency>
 <groupId>org.slf4j</groupId>
 <artifactId>slf4j-jdk14</artifactId>
 <version>1.6.1</version>
</dependency>

Används Hibernate eller JSF 2 räcker det oftast med att lägga till ovanstående beroenden så länge de finns tillgängliga i applikationens class path. Används JSF 2 går det till exempel att aktivera validering för ett inmatningsfält på följande sätt:

<h:inputText value="#{customer.age}">
  <f:validateBean/>
</h:inputText>

Bean validation stödjer dessutom validering av grupper som gör det möjligt att validera olika aspekter av ett objekt:

@Min(value=15, groups=AgeCheck.class)
private int age;