28 April, 2012

Собственная реализация методов в Spring Data JPA

Очевидно, что мы не всегда можем воспользоваться автоматической генерацией кода, предоставляемой Spring Data JPA. Например, у нас слишком сложный запрос, или нам необходимо вызвать процедуру в базе данных, либо у нас сложная бизнес-логика. Рассмотрим следующий пример - например, нам нужна функциональность уникального счётчика, который мы решили реализовать с помощью последовательности (sequence). Сначала определим интерфейс, в котором опишем все методы, которые мы будем реализовывать самостоятельно. В нашем случае, это будет только один метод:
public interface UserRepositoryCustom {
    /**
     * Returns next unique id.
     *
     * @return next unique id.
     */
    Integer getNextUniqueId();
}

Затем обновим объявление репозитория, чтобы он унаследовал новый интерфейс UserRepositoryCustom

public interface UserRepository extends JpaRepository<User, Integer>, UserRepositoryCustom {
   ...
}

Теперь напишем реализацию метода:
public class UserRepositoryImpl implements UserRepositoryCustom {

    @PersistenceContext
    private EntityManager entityManager;

    @Override
    public Integer getNextUniqueId() {

        // When using Hibernate via JPA native queries fails with mapping exception, so just use Hibernate directly:
        Session session = (Session) entityManager.getDelegate();
        SQLQuery nativeQuery = session.createSQLQuery("SELECT \"nextval\"('unique_id_seq') ");
        List<BigInteger> list = nativeQuery.list();
        if (list.isEmpty()) {
            throw new IncorrectResultSizeDataAccessException(1);
        }

        BigInteger result = list.get(0);

        return result.intValue();
    }
}
И, наконец, укажем Spring Data JPA, чтобы в качестве класса для прокси использовался наш класс с реализацией собственных методов. Для этого нам нужна ещё одна секция repositories в конфигурационном файле:
    <repositories base-package="[base.repository.package]"/>

    <repositories base-package="[base.repository.package]">
        <repository id="userRepository" custom-impl-ref="userRepositoryImpl"/>
    </repositories>

    <beans:bean id="userRepositoryImpl" class="...UserRepositoryImpl"/>
Вот и всё.

24 April, 2012

Ищем с помощью Spring Data JPA

Рассмотрим подробнее одну из наиболее полезных вещей в Spring Data JPA - генерация JPQL-запросов на основе имени метода. Spring Data JPA умеет автоматически генерировать запросы используя для подсказки название метода. Например, метод User.findByLoginAndPassword сгенерирует примерно следующий код:
    FROM User u where u.login = :login and password = :password
Вообще Spring Data JPA пытается быть умным, поэтому реализация findBy{...} методов ищется следующим образом:
  1. Сначала смотрится аннотация @Query на объявлении метода, если она есть, то используется.
  2. Затем смотрится аннотация @NamedQuery с именем вида Entity.findMethodName, для вышеприведённого случая это будет User.findByLoginAndPassword.
  3. Если ничего не нашли. то по сигнатуре метода генерируется запрос.
У @Query следующие плюсы:
  1. Позволяет не засорять объявление доменной сущности.
  2. Сильно помогает, если у нас в запросе есть неявные джойны, потому что для таких запросов Spring Data JPA не умеет корректно генерировать запрос SELECT COUNT(*), который нужен в тех случаях, когда метод должен вернуть Page.
Очевидно, что при использовании запросов нам необходимо каким-то образом указывать параметры для запросов. Для этого есть аннотация @Param:
    @Query("select u from User u where u.login = :login and u.password = :password")
    Page<User> findByLoginAndPassword(@Param("login") String login, @Param("password") String password);
Кроме того, Spring Data JPA поддерживает отличную концепцию спецификаций. Спецификации позволяют делать составлять сложные запросы из набора простых. Для поддержки спецификаций необходимо объявить метод в репозитории:
    Page<User> findAll(Specification<User> spec, Pageable pageable);
Спецификация по сути является фильтром и позволяет комбинирование фильтров, что даёт мощный инструмент для построения запросов. Пример использования спецификаций: Объявляем наши спецификации:
        public static Specification<User> firstNameOrLastNameOrLoginLike(final String search) {
            return new Specification<User>() {
                @Override
                public Predicate toPredicate(Root<User> root, CriteriaQuery<?> query, CriteriaBuilder builder) {

                    Predicate loginPredicate = builder.like(root.get(User_.login), search);
                    Predicate firstnamePredicate = builder.like(root.get(User_.firstname), search);
                    Predicate lastnamePredicate = builder.like(root.get(User_.lastname), search);

                    return builder.or(loginPredicate, firstnamePredicate, lastnamePredicate);
                }
            };
        }

        public static Specification<User> hasRole(final Role role) {
            return new Specification<User>() {
                @Override
                public Predicate toPredicate(Root<User> root, CriteriaQuery<?> query, CriteriaBuilder builder) {
                    return builder.equal(root.get(User_.role), role);
                }
            };
        }
И в нашем сервисе комбинируем их:

        public Page<User> searchUser(Role role, String search, Pageable pageable) {
            Specifications<User> mainSpec = where(hasRole(role));

            // уточняем запрос, если была передана строка для поиска
            if (StringUtils.isNotBlank(search)) {
                mainSpec = mainSpec.and(firstNameOrLastNameOrLoginLike(search));
            } 

            return userRepository.findAll(mainSpec, pageable);
        }

20 April, 2012

Использование BeanPostProcessor на примере журналирования

Сегодня я хочу рассказать, как можно сделать инициализацию логгера в классе с использованием аннотаций и BeanPostProcessor Очень часто мы инициализируем логгер следующим образом:
public class MyClass {
    private static final Logger LOG = LoggerFactory.getLogger(MyClass.class);
}
Я покажу, как сделать, чтобы можно было писать вот так:
    @Log
    private Logger LOG;
Первым делом нам нужно объявить аннотацию:
@Retention(RUNTIME)
@Target(FIELD)
@Documented
public @interface Log {
    String category() default "";
}
А вторым делом, написать собственный BeanPostProcessor, который бы устанавливал нам логгер:
import org.apache.commons.lang.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.stereotype.Component;
import org.springframework.util.ReflectionUtils;

@Component
public class LoggerPostProcessor implements BeanPostProcessor {
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) {
        return bean;
    }

    @Override
    public Object postProcessBeforeInitialization(final Object bean, final String beanName) {
        ReflectionUtils.doWithFields(bean.getClass(), new FieldProcessor(bean, beanName), new LoggerFieldFilter());
        return bean;
    }

    private static class FieldProcessor implements ReflectionUtils.FieldCallback {
        private final Object bean;
        private final String beanName;

        private FieldProcessor(Object bean, String beanName) {
            this.bean = bean;
            this.beanName = beanName;
        }

        @Override
        public void doWith(Field field) throws IllegalAccessException {
            Log loggerAnnot = field.getAnnotation(Log.class);

            // Sanity check if annotation is on the field with correct type.
            if (field.getType().equals(org.slf4j.Logger.class)) {
                // As user can override logger category - check if it was done.
                String loggerCategory = loggerAnnot.category();
                if (StringUtils.isBlank(loggerCategory)) {
                    // use default category instead.
                    loggerCategory = bean.getClass().getName();
                }
                Logger logger = LoggerFactory.getLogger(loggerCategory);
                ReflectionUtils.makeAccessible(field);
                field.set(bean, logger);
            } else {
                throw new IllegalArgumentException(
                    "Unable to set logger on field '" + field.getName() + "' in bean '" + beanName +
                        "': field should have class " + Logger.class.getName());
            }
        }
    }

    private static class LoggerFieldFilter implements ReflectionUtils.FieldFilter {
        @Override
        public boolean matches(Field field) {
            Log logger = field.getAnnotation(Log.class);
            return null != logger;
        }
    }
}
Если вы используете не sfl4j, а, например, log4j, или commons-logging, то нужно немного поправить код внутри метода doWith Попутно, данный код показывает пример использования класса org.springframework.util.ReflectionUtils.

Преобразуем строку в дату

Казалось бы, есть простейшая задача - преобразовать строковое представление даты в объект класса java.util.Date. Как оказалось, иногда использование DateFormat не помогает. В случае, если строка - это заголовок Date из письма, то нам нужно использовать javax.mail.internet.MailDateFormat для преобразования такой строки.
String dateStr = ...
Date parsedDate = new MailDateFormat().parse(dateStr);

22 February, 2012

Упрощаем работу с JPA при помощи Spring Data JPA

Введение

Уже прошло несколько лет с тех пор, как появился JPA. Работа с EntityManager увлекательна, но разработчики пишут красивый API, а подробности работы с базой данных скрывают. При этом частая проблема - дублирование имплементации, когда из одного DAO в другой у нас плавно перекочёвывает один и тот же код, в лучшем случае этот код переносится в абстрактный базовый DAO. Spring Data коренным образом решает проблему - при его использовании остаётся только API на уровне интерфейсов, вся имплементация создаётся автоматически с использованием AOP.

История Spring Data

Несмотря на то, что проект только недавно достиг версии 1.0, у него достаточно богатая история - раньше он развивался в рамках проекта Hades.

Объявление DAO-интерфейса

Итак, для начала нам необходимо объявить DAO-интерфейс, в котором мы будем объявлять методы для работы с сущностью.
public interface UserRepository extends CrudRepository<User, Long> {
}
Данного кода достаточно для обычного DAO с CRUD-методами.
  • save - сохраняет или обновляет переданную сущность.
  • findOne - ищет сущность по первичному ключу.
  • findAll - возвращает коллекцию всех сущностей
  • count - возвращает количество сущностей
  • delete - удаляет сущность
  • exists - проверяет, существует ли сущность с данным первичным ключом
Полный список методов, объявленный в CrudRepository можно посмотреть в javadoc. В случае, если нам нужны не все методы, то есть возможность произвести наследование от интерфейса Repository и перенести в наследника только те методы из интерфейса CrudRepository, которые нужны.

Поддержка сортировки и постраничного просмотра

Очень часто требующаяся функциональность - это возможность возвращать только часть сущностей из БД, например, для реализации постраничного просмотра в пользовательском интерфейсе. Spring Data и тут хорош и предоставляет нам возможность добавить такую функциональность в наш DAO. Для этого достаточно добавить объявление следующего метода в наш DAO-интерфейс:
 Page<User> findAll(Pageable pageable);
Интерфейс Pageable инкапсулирует в себе сведения о номере запрашиваемой страницы, размере страницы, а также требуемой сортировке.

Ищем данные

Как правило, на обычных CRUD-ах DAO не заканчиваются и часто требуются дополнительные методы, которые возвращают только те сущности, которые удовлетворяют заданным условиям. На мой взгляд, Spring Data сильно упрощает жизнь в данной области. Например, нам нужен методы для поиска пользователя по логину и по его e-mail адресу:
 User findByLogin(String login);
 User findByEmail(String email);
Все просто. В случае, если нужны более сложные условия для поиска, то и это тоже реализовано. Spring Data поддерживает следующие операторы:
  • Between
  • IsNotNull
  • NotNull
  • IsNull
  • Null
  • LessThan
  • LessThanEqual
  • GreaterThan
  • GreaterThanEqual
  • NotLike
  • Like
  • NotIn
  • In
  • Near
  • Within
  • Regex
  • Exists
  • IsTrue
  • True
  • IsFalse
  • False
  • Not
Такой внушительный список открывает простор для фантазии, так что можно составить сколь угодно сложный запрос. Если необходимо, чтобы в результатах поиска было несколько сущностей, то необходимо называть метод findAllByBlahBlah

Поддержка Spring MVC

Это часть основана на официальной документации. Представьте, что вы разрабатываете веб-приложение с использованием Spring MVC. Тогда вам необходимо будет загружать сущность из базы данных используя параметры HTTP-запроса. Это может выглядеть следующим образом:
@Controller
@RequestMapping("/users")
public class UserController {

  private final UserRepository userRepository;

  public UserController(UserRepository userRepository) {
    userRepository = userRepository;
  }

  @RequestMapping("/{id}")
  public String showUserForm(@PathVariable("id") Long id, Model model) {
    
    // Do null check for id
    User user = userRepository.findOne(id);
    // Do null check for user
    // Populate model
    return "user";
  }
}
Во-первых, вы объявляете зависимость на DAO, а во-вторых всегда вызываете метод findOne() для загрузки сущности. К счастью, Spring позволяет нам преобразовывать строковые значения из HTTP-запросов в любой нужный тип используя либо PropertyEditor, либо ConversionService. Если вы используете Spring версии 3.0 и выше, то вам необходимо добавить следующую конфигурацию:
<mvc:annotation-driven conversion-service="conversionService" />
<bean id="conversionService" class="….context.support.ConversionServiceFactoryBean">
  <property name="converters">
    <list>
      <bean class="org.springframework.data.repository.support.DomainClassConverter">
        <constructor-arg ref="conversionService" />
      </bean>
    </list>
  </property>
</bean>
Если же вы используете Spring более старой версии, то вам необходима вот такая конфигурация:
<bean class="….web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter">
  <property name="webBindingInitializer">
    <bean class="….web.bind.support.ConfigurableWebBindingInitializer">
      <property name="propertyEditorRegistrars">
        <bean class="org.springframework.data.repository.support.DomainClassPropertyEditorRegistrar" />
      </property>
    </bean>
  </property>
</bean>
После данных изменений в конфигурации можно переписать контроллер следующим образом:

@Controller
@RequestMapping("/users")
public class UserController {

  @RequestMapping("/{id}")
  public String showUserForm(@PathVariable("id") User user, Model model) {

    // Do null check for user
    // Populate model
    return "userForm";
  }
}
Обратите внимание на то, как упростился код и как мы красиво избавились от его дублирования.

Документация

На данный момент документации по проекту не так уж и много, но, тем не менее, она есть:

Заключение

Spring Data значительно упрощает жизнь при использовании JPA. Рекомендуется к использованию в своих проектах.

08 February, 2012

Разработка и тестирование Java REST веб-сервисов

Введение

Для разработки REST веб-сервисов Java предлагает JSR-311 - JAX-RS: The Java™ API for RESTful Web Services Как это обычно бывает в мире Enterprise Java, существует несколько реализаций данной спецификации: На примере последней реализации, я и расскажу, каким образом можно написать REST-сервис.

Пишем REST-сервис


import javax.ws.rs.*;
import javax.ws.rs.core.MediaType;

@Path("/service/entity")
@Produces({MediaType.APPLICATION_XML, MediaType.APPLICATION_JSON})
public interface EntityRestService {

 @GET
 @Path("/all")
 EntityList listAll();

 @GET
 @Path("/{id}")
 Entity findById(@PathParam("id") Integer id);


}
Создаём интерфейс, в котором расставляем JAX-RS аннотации. Аннотация @Path указывает путь, по которому будет доступен наш сервис. Аннотация @GET определяет, какой HTTP-запрос будет обрабатываться данным методом. Аннотация @Produces позволяет указать, в каком формате данный сервис предоставляет результаты.

Конфигурация JBoss RESTEasy

Конфигурация очень проста, во-первых, нам нужно добавить обновить pom.xml и добавить необходимые зависимости:
Обновляем pom.xml
Добавляем compile-time зависимость на JAX-RS API
<dependency>
    <groupId>org.jboss.resteasy</groupId>
    <artifactId>jaxrs-api</artifactId>
</dependency>
и runtime зависимости на реализацию
<dependency>
    <groupId>org.jboss.resteasy</groupId>
    <artifactId>resteasy-jaxrs</artifactId>
    <version>${resteasy-jaxrs.version}</version>
    <scope>runtime</scope>
</dependency>
<dependency>
    <groupId>org.jboss.resteasy</groupId>
    <artifactId>resteasy-jackson-provider</artifactId>
    <version>${resteasy-jaxrs.version}</version>
    <scope>runtime</scope>
</dependency>

Обновляем конфигурацию веб-приложения в web.xml
Необходимо выполнить следующую модификацию web.xml
 <listener>
  <listener-class>org.jboss.resteasy.plugins.server.servlet.ResteasyBootstrap</listener-class>
 </listener>

 <context-param>
  <param-name>resteasy.servlet.mapping.prefix</param-name>
  <param-value>/rest</param-value>
 </context-param>
 <servlet>
  <servlet-name>REST Easy</servlet-name>
  <servlet-class>org.jboss.resteasy.plugins.server.servlet.HttpServletDispatcher</servlet-class>
 </servlet>
 <servlet-mapping>
  <servlet-name>REST Easy</servlet-name>
  <url-pattern>/rest/*</url-pattern>
 </servlet-mapping>
Данный код объявляет сервлет HttpServletDispatcher, который будет обрабатывать все запросы, которые приходят на /rest/*. Слушатель ResteasyBootstrap выполняет всю необходимую инициализацию JBoss RESTEasy.
Поддержка Spring
Для того, чтобы использовать Spring Framework, нам необходимо сделать следующие изменения: 1. Добавить зависимость в pom.xml
<dependency>
    <groupId>org.jboss.resteasy</groupId>
    <artifactId>resteasy-spring</artifactId>
    <version>${resteasy-jaxrs.version}</version>
    <scope>runtime</scope>
</dependency>
2. Добавить Spring-ового слушателя в web.xml
 <listener>
  <listener-class>org.jboss.resteasy.plugins.spring.SpringContextLoaderListener</listener-class>
 </listener>

После этих изменений JBoss RESTEasy будет в курсе про Spring, это позволит в реализации REST-сервисов полноценно использовать все возможности, предоставляемые Spring Framework.

Пишем тесты

Написание тестов - весьма полезная вещь, ниже я покажу пример теста для REST-сервиса. В рамках данного теста у нас будет подниматься встраиваемый веб-сервер TJWSEmbeddedJaxrsServer, к которому мы будем обращаться для тестирования наших REST-сервисов.

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration({"/applicationContext-test.xml"})
@TestExecutionListeners({DependencyInjectionTestExecutionListener.class, DirtiesContextTestExecutionListener.class})
public class TestEntityServiceRest {

 private static final int PORT = 8081;
 private static final String BASE_URL = "http://localhost:" + PORT;

 @Autowired
 EntityService entityService;

 @Autowired
 ConfigurableApplicationContext applicationContext;


 protected HttpClient client;
 protected TJWSEmbeddedJaxrsServer server;


 @Before
 public void setUpClient() throws Exception {
  client = new DefaultHttpClient();
 }

 @Before
 public void setUpServer() throws Exception {
  server = new TJWSEmbeddedJaxrsServer();
  server.setPort(PORT);
  ResteasyDeployment deployment = server.getDeployment();

  server.start();

  Dispatcher dispatcher = deployment.getDispatcher();
  SpringBeanProcessor processor = new SpringBeanProcessor(dispatcher, deployment.getRegistry(), deployment.getProviderFactory());
  applicationContext.addBeanFactoryPostProcessor(processor);

  SpringResourceFactory noDefaults = new SpringResourceFactory(
    "entityServiceRestImpl", applicationContext, EntityRestServiceImpl.class);
  dispatcher.getRegistry().addResourceFactory(noDefaults);
 }

 @After
 public void stop() {
  server.stop();
 }

 @Test
 public void testListAll() throws Exception {

  int i = 0;
  final List<Entity> returnedList = new ArrayList<Entity>();
  int EXPECTED_SIZE = 6;
  while (i < EXPECTED_SIZE) {
   i++;
   final Entity entity = new Entity();
   entity.setId(i);
   entity.setName("test" + i);
   returnedList.add(entity);
  }
  when(entityService.findAll()).thenReturn(returnedList);


  HttpGet get = new HttpGet(BASE_URL + "/service/entity/");

  HttpResponse response = client.execute(get);
  InputStream content = response.getEntity().getContent();

  EntityList result = fromString(EntityList.class, content);
  content.close();

  Assert.assertNotNull(result);
  Assert.assertEquals(EXPECTED_SIZE, result.getEntities().size());
 }

 @Test
 public void testFindById() throws Exception {

  final Entity validEntity = getValidEntity();
  validEntity.setId(2);

  when(entityService.findById(validEntity.getId())).thenAnswer(new Answer<Object>() {
   @Override
   public Object answer(InvocationOnMock invocation) throws Throwable {
    return validEntity;
   }
  });

  HttpGet get = new HttpGet(BASE_URL + "/service/entity/2");

  HttpResponse response = client.execute(get);
  InputStream content = response.getEntity().getContent();

  Entity result = fromString(Entity.class, content);
  content.close();

  Assert.assertNotNull(result);

  deepAssertEquals(validEntity, result);

 }

 private void deepAssertEquals(Object expected, Object actual) throws IllegalAccessException, InvocationTargetException {
  Assert.assertEquals(expected.getClass(), actual.getClass());
  PropertyDescriptor[] propertyDescriptors = BeanUtils.getPropertyDescriptors(expected.getClass());
  for (PropertyDescriptor propertyDescriptor : propertyDescriptors) {
   Object expectedValue = propertyDescriptor.getReadMethod().invoke(expected);
   Object actualValue = propertyDescriptor.getReadMethod().invoke(actual);
   Assert.assertEquals(expectedValue, actualValue);
  }
 }

        public static <T> T fromString(Class<T> clazz, String input) throws JAXBException {
  JAXBContext ctx = JAXBContext.newInstance(clazz);
  Unmarshaller unmarshaller = ctx.createUnmarshaller();
  @SuppressWarnings("unchecked")
  T unmarshal = (T) unmarshaller.unmarshal(new StringReader(input));
  return unmarshal;
 }

 public static <T> T fromString(Class<T> clazz, InputStream input) throws JAXBException {
  JAXBContext ctx = JAXBContext.newInstance(clazz);
  @SuppressWarnings("unchecked")
  T unmarshal = (T) ctx.createUnmarshaller().unmarshal(input);
  return unmarshal;
 }
}


Запуск тестов

Половина дела сделана, теперь нам необходимо настроить инфраструктуру для тестирования наших свеженаписанных REST-сервисов. Для этого нам необходимо внести следующие модификации в pom.xml:

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-surefire-plugin</artifactId>
    <version>2.11</version>

    <executions>
        <execution>
     <id>Unit tests</id>
            <phase>test</phase>
            <goals>
                <goal>test</goal>
            </goals>
            <configuration>
                <excludes>
                    <exclude>**/IT*.java</exclude>
                </excludes>
            </configuration>
        </execution>
        <execution>
            <id>Integration tests</id>
            <phase>integration-test</phase>
            <goals>
                <goal>test</goal>
            </goals>
            <configuration>
                <includes>
                    <include>**/IT*.java</include>
                </includes>
            </configuration>
        </execution>
    </executions>
</plugin>

<dependency>
    <groupId>org.apache.httpcomponents</groupId>
    <artifactId>httpclient</artifactId>
    <version>4.1.2</version>
    <scope>test</scope>
</dependency>
<dependency>
    <groupId>org.jboss.resteasy</groupId>
    <artifactId>resteasy-jaxrs</artifactId>
    <scope>test</scope>
</dependency>
<dependency>
    <groupId>org.jboss.resteasy</groupId>
    <artifactId>resteasy-spring</artifactId>
    <scope>test</scope>
</dependency>
<dependency>
    <groupId>org.jboss.resteasy</groupId>
    <artifactId>tjws</artifactId>
    <version>${resteasy-jaxrs.version}</version>
</dependency>
<dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>servlet-api</artifactId>
    <scope>test</scope>
</dependency>
<dependency>
    <groupId>commons-io</groupId>
    <artifactId>commons-io</artifactId>
    <scope>test</scope>
</dependency>

Заключение

В целом, ничего сложного, главное делать всё аккуратно. Хорошего вам кода!

27 January, 2012

Немножко магии от AspectJ

Наверно, вы уже сталкивались с таким понятием, как AOП - аспектно-ориентированное программирование.

Обычно, про него вспоминают, когда говорят про декларативное использование транзакций, про проверку прав доступа, либо про реализацию журналирования.

Но это не единственные области применения АОП.

Я хочу показать ещё пару областей применения из реальных проектов:

1. Модификация исходного кода для реализации дополнительных возможностей.
2. Принудительная проверка контракта между модулями.

Модификация исходного кода для реализации дополнительных возможностей

Предположим, что у нас есть модуль в приложении, который предоставляет нужную нам функциональность. С модулем всё в порядке, кроме одного - все его методы могут выбрасывать проверяемые исключения, что ведёт к ухудшению читаемости кода, так как вместо простого вызова метода:

service.doUsefulThing();

наш вызов превращается в

try {
        service.doUsefulThing();
    } catch ( FirstServiceException e) {
        processException(e);
    } catch ( SecondServiceException e) {
        processException(e);
    }

Дополнительная проблема в том, что у модуля количество модулей 10+, количество методов также велико, что приводит к тому, что блоки try/catch замусоривают код. Решение с использованием паттерна Callback также приведёт к замусориванию кода.

Вариант решения проблемы с использованием AOP
Решение данной проблемы было таким - а что, если используя возможности AOP трансформировать проверяемое исключение в непроверяемое? Таким образом, мы сможем избавиться от скучной проверки на исключения в нашем коде, а для обработки исключения (ведь мы всегда его будем обрабатывать одинаково) достаточно будет использовать обработку исключения на верхнем уровне абстракции.

Для более элегантного решения проблемы было решено добавить собственную аннотацию, которой нужно помечать метод, который использует сервис из "плохого" модуля.

package com.blogger.atamanenko;

import java.lang.annotation.Documented;
import java.lang.annotation.Inherited;
import java.lang.annotation.Retention;
import java.lang.annotation.Target;
import java.lang.annotation.RetentionPolicy;

@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD})
@Documented
@Inherited
public @interface SuppressExceptions {
}
    

А также аспект, который бы делал всю нужную нам функциональность:

public aspect ExceptionSupressingAspect {

        declare soft :ServiceException:  execution(@com.blogger.atamanenko.annotation.SuppressExceptions * *.*(..));

}

Данный аспект делает в точности следующее: "Смягчает" исключение ServiceException для метода, который помечен аннотацией @SuppressExceptions.

Пример использования:

@SuppressExceptions
    protected Entity findEntity(final Identifiable id) {
        return entityService.findById(id);
    }

Принудительная проверка контракта между модулями

Часто нам необходимо принудительно требовать выполнения каких-то архитектурных ограничений, например, контроллеры должны работать только с сервисами и им запрещено напрямую обращаться к базе данных.

Для реализации таких проверок можно также использовать возможности AOP.

Предположим, что в нашем приложении модуль сервиса выставляет наружу DTO для работы, скрывая при этом классы модели. Для того, чтобы явно запретить доступ к классам и методам модели нам необходимо создать аспект, который бы вызывал ошибку компиляции при нарушении ограничения.

aspect ForbidAccessToModelAspect {

//      Full prohibition of access to model:
        pointcut accessModel(): call(* com.blogger.atamanenko.app.model..*.*(..));
        declare error: accessModel() : "Illegal call to model";

}

После объявления такого аспекта, мы получим ошибку компиляции, что, очевидным образом, приведёт к выполнению архитектурного ограничения.

Если же нам необходимо разрешить доступ к одному пакету только из какого-то определённого другого, то мы можем модифицировать наш аспект следующим образом:

aspect ForbidAccessToModelAspect2 {

        pointcut accessModel(): call(* com.blogger.atamanenko.app.model.**.*(..));

        // Allow access to model from specific package for methods and constructors
        pointcut allowAccessModelFromSpecificPackage(): withincode(* com.blogger.atamanenko.app.allowedpackage..*.*(..));
        pointcut allowAccessModelFromSpecificPackage2(): withincode(com.blogger.atamanenko.app.allowedpackage..*.new(..));

        // forbid usage from any other methods.
        declare error: accessModel() && !(allowAccessModelFromSpecificPackage() || allowAccessModelFromSpecificPackage()):"Illegal call to Model from forbidden package";

}


Такой аспект, созданный в нашем модуле запретит нам использовать классы модели из всех пакетов, кроме com.blogger.atamanenko.app.allowedpackage

Сборка приложения

Файл аспекта нужно положить в каталог src/main/aspect, а для сборки приложения необходимо использовать не стандартный Oracle Java Compiler, а AspectJ compiler.

Пример конфигурации для Apache Maven:

<plugin>
    <groupId>org.codehaus.mojo</groupId>
    <artifactId>aspectj-maven-plugin</artifactId>
    <version>${aspectj-maven-plugin.version}</version>
    <configuration>
        <complianceLevel>1.6</complianceLevel>
        <aspectLibraries>
            <aspectLibrary>
                <groupId>org.springframework</groupId>
                <artifactId>spring-aspects</artifactId>
            </aspectLibrary>
        </aspectLibraries>
        <verbose>true</verbose>
    </configuration>
    <executions>
        <execution>
            <phase>process-sources</phase>
            <goals>
                <goal>compile</goal>
                <goal>test-compile</goal>
            </goals>
        </execution>
    </executions>
</plugin>

Заключение

Вот в общем-то и всё. Я сознательно не стал описывать языковые конструкции аспектов, так как они подробно описаны в руководстве AspectJ

21 July, 2011

Немного о виртуальных методах в Java

Сегодня я хочу рассмотреть некоторые особенности переопределения методов в Java. В java нельзя переопределить:
  • поля класса
  • конструкторы, инициализаторы класса
  • статические методы
  • статические поля

Подробнее об этом можно прочитать в Java Language Specification, §8.4.8

Итак, в java все нестатические неприватные (то есть, protected, package и public) методы являются виртуальными. Ключевое слово final запрещает возможность дальнейшего переопределения метода в подклассах. Рассмотрим следующий пример:

public class A {
     int i = 3;
     int getI() {return i;}
}

public class B extends A{
     int i = 5;
     int getI() {return i;}
}

A a = new B();
System.out.println(a.i);
System.out.println(a.getI());


Вопрос: что выведет данный код?
Ответ:
1. Так как поля класса не наследуются, то у класса A своё поле i и у класса B тоже своё поле i. Так как для полей полиморфизм не действует, то при обращении a.i мы обращаемся к классу A, поэтому на экран будет выведено 3.
2. При вызове метода a.getI() у нас в дело вступает полиморфизм, поэтому будет вызван метод от класса, инстанс которого был создан. Соответственно, мы получим на выходе 5.


Другой пример:

public class A {
     static int i = 3;
     static int getI() {return i;} 
}

public class B extends A{
     static int i = 5;
     static int getI() {return i;}
}

A a = new B();
System.out.println(a.i);
System.out.println(a.getI());


Статические поля и методы виртуальными не являются, поэтому оба вызова выведут нам 3.

06 December, 2010

Сокращаем ссылки на андроиде

Вступление
Встала передо мной задача - сокращать ссылки перед тем, как отправлять их в Twitter. Для решения этой задачи я решил использовать bit.ly, благо, их API внятный и простой.
Программируем!
Решение нарисовалось в виде следующего класса:
import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.NameValuePair;
import org.apache.http.client.ClientProtocolException;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.utils.URIUtils;
import org.apache.http.client.utils.URLEncodedUtils;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.util.EntityUtils;
import org.json.JSONException;
import org.json.JSONObject;

import android.util.Log;

import java.io.IOException;
import java.net.URI;
import java.net.URISyntaxException;
import java.util.ArrayList;
import java.util.List;


/**
 * Helper class to work with bitly.
 *
 * @author Oleg Atamanenko
 * @since 06-Dec-2010 12:49:36
 */
public class Bitly {

    private static final String TAG = "Bitly";

    private static final String SHORTEN = "/v3/shorten";
    private static final String API_URL = "api.bit.ly";
    private static final String RESPONSE_FORMAT = "json";

    private String username;
    private String apiKey;


    public Bitly(String username, String apiKey) {
        this.username = username;
        this.apiKey = apiKey;
    }

    public String shorten(String longUrl) throws BitlyException {
        DefaultHttpClient httpClient = new DefaultHttpClient();

        try {
            List params = new ArrayList();
            params.add(new BasicNameValuePair("login", username));
            params.add(new BasicNameValuePair("apiKey", apiKey));
            params.add(new BasicNameValuePair("longUrl", longUrl));
            params.add(new BasicNameValuePair("format", RESPONSE_FORMAT));


            URI uri = URIUtils.createURI("http", API_URL, -1, SHORTEN, URLEncodedUtils.format(params, "UTF-8"), null);
            HttpGet request = new HttpGet(uri);

            Log.d(TAG, "Sending request: " + request.getURI());

            HttpResponse httpResponse = httpClient.execute(request);

            HttpEntity httpEntity = httpResponse.getEntity();
            String response = EntityUtils.toString(httpEntity);
            Log.i(TAG, "Bitly response is: " + response);
            httpResponse.getEntity().consumeContent();

            JSONObject jsonResponse = new JSONObject(response);

            checkForExceptions(jsonResponse);

            JSONObject data = jsonResponse.getJSONObject("data");
            return data.getString("url");

        } catch (ClientProtocolException e) {
            throw new BitlyException(e);
        } catch (IOException e) {
            throw new BitlyException(e);
        } catch (JSONException e) {
            throw new BitlyException(e);
        } catch (URISyntaxException e) {
            throw new BitlyException(e);
        }
    }

    private void checkForExceptions(JSONObject jsonResponse) throws JSONException, BitlyException {
        int statusCode = jsonResponse.getInt("status_code");
        if (statusCode != 200) {
            String message = jsonResponse.getString("status_txt");
            throw new BitlyException(message);
        }
    }

}
Конструктор класс принимает на вход следующие параметры: Полная документация к Bit.ly API расположена на отдельном проекте в Google Code
Использование
Единственный метод, реализованный сейчас - это метод shorten(). На вход требуется подать полную ссылку longUrl, на выходе получается укороченная версия ссылки, либо кидается исключение с сообщением от bit.ly API.
Пример вызова
Bitly bitly = new Bitly(BITLY_USERNAME, BITLY_API_KEY);
String shortLink = bitly.shorten(link);

Дальнейшие улучшения
Если перед вами стоит задача быстренько сократить ссылку - то вышеприведённого кода достаточно. Но если вам нужно полноценное решение, со всеми возможностями bit.ly - то посмотрите в сторону bitlyj. Правда, я не уверен, что оно взведётся под андроидом.