Unsorted list:
- If you use a versioning control system, spend some time learning its basic usage (checkout, checkin, update, diff, merge, …). If you don’t use it, go quickly to get one. Im currently using svn and git.
- Write your own documentation. Document your work for your personal profit. While you are documenting and organizing you are thinking in your job by looking it from a different point of view. Think in documentation like in a software-piece, it must be useful and reusable.
- Constantly, try to improve your knowledge about every day tools usage by knowing its internals (keyboard shorcuts or processes) or just learning from your colleages (or Internet users) usage.
- Don’t be IDE-dependent for your compilation, use scripts or tools specifically designed for this task. Actually Maven will be my first choice because Java is my main plattform.
- Get feedback about your code. Show them into colleagues or use communities like StackOverflow.
- Don’t try to write your own framework or libraries for later use. Learn writing it if you want, but use well-known community libraries or frameworks. I personally work mainly with Spring Framework and Apache commons.
- Backup your data. Use your own/preferred method. I personally like dropbox.
- Most important. Don’t try to acomplish all of this at same time. Just be patient and
Please, feedback
Best-Practices, Code, HowTo, Java, Tools
Best-Practices, Code, Java
applicationContext.xml:
File parameters.properties / Fichero parameters.properties:
MyComponent.path=/some/path
Spring component / Componente gestionado por Spring:
import javax.annotation.PostConstruct;
import org.springframework.stereotype.Component;
@Component("MyComponent")
public class MyComponent {
private String path;
@PostConstruct
public void loadPath() {
System.out.println("Loading from " + this.path);
}
public String getPath() {
return path;
}
public void setPath(String path) {
this.path = path;
}
}
HowTo, Java, Spring
HowTo, Java, Spring
Simply a code I wrote today at my Spring Training / Simplemente un código que escribí hoy en el curso de Spring.
applicationContext.xml:
1
2
3
4
5
6
7
8
9
10
| <?xml version="1.0" encoding="UTF-8" ?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">
<bean id="postProcessor" class="com.sourcerebels.test.postprocessor.PostProcessor"/>
<bean id="someBusinessRule" class="com.sourcerebels.test.postprocessor.SomeBusinessRule" lazy-init="true">
<property name="message" value="someBusinessRule executed"/>
</bean>
</beans> |
Advice:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
| package com.sourcerebels.test.postprocessor;
import java.lang.reflect.Method;
import org.springframework.aop.AfterReturningAdvice;
import org.springframework.aop.MethodBeforeAdvice;
public class TransactionAdvice implements MethodBeforeAdvice, AfterReturningAdvice {
public void before(Method method, Object[] args, Object target) throws Throwable {
System.out.println("Starting Transaction");
}
public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
System.out.println("Commit Transaction");
}
} |
BusinessRule interface:
1
2
3
4
5
6
| package com.sourcerebels.test.postprocessor;
public interface BusinessRule {
void run();
} |
SomeBusinessRule class:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
| package com.sourcerebels.test.postprocessor;
public class SomeBusinessRule implements BusinessRule {
private String message;
public void run() {
System.out.println(message);
}
public String getMessage() {
return message;
}
public void setMessage(String message) {
this.message = message;
}
} |
Postprocessor:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
| package com.sourcerebels.test.postprocessor;
import org.springframework.aop.framework.ProxyFactory;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;
/**
* @author edu@sourcerebels.com
*/
public class PostProcessor implements BeanPostProcessor {
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
System.out.println("postProcessBeforeInitialization");
return bean;
}
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
System.out.println("postProcessAfterInitialization");
if (bean instanceof BusinessRule) {
System.out.println("building proxy object");
ProxyFactory proxyFactory = new ProxyFactory(bean);
proxyFactory.addInterface(BusinessRule.class);
proxyFactory.addAdvice(new TransactionAdvice());
return proxyFactory.getProxy();
}
return bean;
}
} |
Main:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
| package com.sourcerebels.test.postprocessor;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class Main {
public static void main(String[] args) {
String[] paths = { "com/sourcerebels/test/postprocessor/applicationContext.xml" };
ApplicationContext ctx = new ClassPathXmlApplicationContext(paths);
BusinessRule negocio = (BusinessRule) ctx.getBean("someBusinessRule");
negocio.run();
negocio = (BusinessRule) ctx.getBean("someOtherBusinessRule");
negocio.run();
}
} |
Design Patterns, HowTo, Java, Spring
Design Patterns, Java, Spring