What is the general feeling for the case of hostnames in Linux/UNIX, is it preferable to have them in lower-case or upper-case? I have always preferred them as lower-case but I am interested to see if there are any arguments for or against this practice.


Host names are case insensitive.

Lower case has been the standard usage ever since there has been domain name servers.



source - http://forums.fedoraforum.org/showthread.php?t=268929





'System > Linux' 카테고리의 다른 글

linux - bootproto static vs none  (1) 2014.09.18
linux - difference between adduser and useradd  (0) 2014.09.18
linux - Install RPM Fusion Repository  (0) 2014.09.04
linux - grep and or  (0) 2014.09.02
linux - sshfs  (0) 2014.08.25
Posted by linuxism
,

you can do it like this:


Code:

public void post() {

    MultiValueMap<String, String> map = new LinkedMultiValueMap<String, String>();

    map.add("name", "xx");

    map.add("password", "xx");

    String result = rest.postForObject("http://localhost:8080/soa-server/user/", map, String.class);

    System.out.println(result);

}


and before you use resttemplate you must init it :

Code:

RestTemplate rest = new RestTemplate();

HttpMessageConverter formHttpMessageConverter = new FormHttpMessageConverter();

HttpMessageConverter stringHttpMessageConverternew = new StringHttpMessageConverter();

rest.setMessageConverters(new HttpMessageConverter[]{formHttpMessageConverter, stringHttpMessageConverternew});


my english is not very good , sorry. I do not know can you understand me

Last edited by oakeye; Nov 24th, 2009, 06:40 PM.



source - http://forum.spring.io/forum/spring-projects/web/70845-sending-post-parameters-with-resttemplate-requests








HttpClient with SSL

If you're new here, you may want to get my "Spring Security for REST" eBook. Thanks for visiting!

1. Overview

This article will show how to configure the Apache HttpClient 4 with SSL support. The goal is simple – consume HTTPS URLs which do not have valid certificates.

If you want to dig deeper and learn other cool things you can do with the HttpClient – head on over to the main HttpClient tutorial.

2. The SSLPeerUnverifiedException

Without configuring SSL with the HttpClient, the following test – consuming an HTTPS URL – will fail:

1
2
3
4
5
6
7
8
9
10
11
12
public class HttpLiveTest {
 
    @Test(expected = SSLPeerUnverifiedException.class)
    public void whenHttpsUrlIsConsumed_thenException()
      throws ClientProtocolException, IOException {
        DefaultHttpClient httpClient = new DefaultHttpClient();
        String urlOverHttps = "https://localhost:8080/spring-security-rest-basic-auth";
        HttpGet getMethod = new HttpGet(urlOverHttps);
        HttpResponse response = httpClient.execute(getMethod);
        assertThat(response.getStatusLine().getStatusCode(), equalTo(200));
    }
}

The exact failure is:

1
2
3
4
javax.net.ssl.SSLPeerUnverifiedException: peer not authenticated
    at sun.security.ssl.SSLSessionImpl.getPeerCertificates(SSLSessionImpl.java:397)
    at org.apache.http.conn.ssl.AbstractVerifier.verify(AbstractVerifier.java:126)
    ...

The javax.net.ssl.SSLPeerUnverifiedException exception occurs whenever a valid chain of trust couldn’t be established for the URL.

3. Configure SSL – Accept All (HttClient < 4.3)

Let’s now configure the http client to trust all certificate chains regardless of their validity:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
@Test
public void givenAcceptingAllCertificates_whenHttpsUrlIsConsumed_thenException()
  throws IOException, GeneralSecurityException {
    TrustStrategy acceptingTrustStrategy = new TrustStrategy() {
        @Override
        public boolean isTrusted(X509Certificate[] certificate, String authType) {
            return true;
        }
    };
    SSLSocketFactory sf = new SSLSocketFactory(acceptingTrustStrategy,
      SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);
    SchemeRegistry registry = new SchemeRegistry();
    registry.register(new Scheme("https", 8443, sf));
    ClientConnectionManager ccm = new PoolingClientConnectionManager(registry);
 
    DefaultHttpClient httpClient = new DefaultHttpClient(ccm);
 
    HttpGet getMethod = new HttpGet(urlOverHttps);
    HttpResponse response = httpClient.execute(getMethod);
    assertThat(response.getStatusLine().getStatusCode(), equalTo(200));
}

With the new TrustStrategy now overriding the standard certificate verification process (which should consult a configured trust manager) – the test now passes and the client is able to consume the HTTPS URL.

4. The Spring RestTemplate with SSL (HttpClient < 4.3)

Now that we have seen how to configure a raw HttpClient with SSL support, let’s take a look at a more high level client – the Spring RestTemplate.

With no SSL configured, the following test fails as expected:

1
2
3
4
5
6
7
@Test(expected = ResourceAccessException.class)
public void whenHttpsUrlIsConsumed_thenException() {
    ResponseEntity<String> response =
      new RestTemplate().exchange(urlOverHttps, HttpMethod.GET, null, String.class);
    assertThat(response.getStatusCode().value(), equalTo(200));
}

So let’s configure SSL:

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
29
30
31
32
33
34
35
36
import static org.apache.http.conn.ssl.SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER;
import java.security.GeneralSecurityException;
import java.security.cert.X509Certificate;
import org.apache.http.auth.AuthScope;
import org.apache.http.auth.UsernamePasswordCredentials;
import org.apache.http.conn.scheme.Scheme;
import org.apache.http.conn.ssl.SSLSocketFactory;
import org.apache.http.conn.ssl.TrustStrategy;
import org.apache.http.impl.client.DefaultHttpClient;
import org.springframework.http.HttpMethod;
import org.springframework.http.ResponseEntity;
import org.springframework.http.client.HttpComponentsClientHttpRequestFactory;
import org.springframework.web.client.ResourceAccessException;
import org.springframework.web.client.RestTemplate;
 
...
@Test
public void givenAcceptingAllCertificates_whenHttpsUrlIsConsumed_thenException()
  throws GeneralSecurityException {
    HttpComponentsClientHttpRequestFactory requestFactory =
      new HttpComponentsClientHttpRequestFactory();
    DefaultHttpClient httpClient = (DefaultHttpClient) requestFactory.getHttpClient();
    TrustStrategy acceptingTrustStrategy = new TrustStrategy() {
    @Override
        public boolean isTrusted(X509Certificate[] certificate, String authType) {
            return true;
        }
    };
    SSLSocketFactory sf = new SSLSocketFactory(acceptingTrustStrategy, ALLOW_ALL_HOSTNAME_VERIFIER);
    httpClient.getConnectionManager().getSchemeRegistry().register(new Scheme("https", 8443, sf));
 
    ResponseEntity<String> response = new RestTemplate(requestFactory).
      exchange(urlOverHttps, HttpMethod.GET, null, String.class);
    assertThat(response.getStatusCode().value(), equalTo(200));
}

As you can see, this is very similar to the way we configured SSL for the raw HttpClient – we configure the request factory with SSL support and then we instantiate the template passing this preconfigured factory.

5. Conclusion

This tutorial discussed how to configure SSL for an Apache HttpClient so that it is able to consume any HTTPS URL, regardless of the certificate. The same configure for the Spring RestTemplate is also illustrated.

An important thing to understand however is that this strategy entirely ignores certificate checking– which makes it insecure and only to be used where that makes sense.

The implementation of these examples can be found in the github project – this is an Eclipse based project, so it should be easy to import and run as it is.



source - http://www.baeldung.com/httpclient-ssl



* 최신 버전에서 에러 발생








Using RestTemplate with Basic Auth

Recently I was trying to write integration tests using Spring’s RestTemplate to make REST calls to an integration server. The server was secured using basic auth over https, and the SSL certificate was a self-signed cert created for development use only. I wanted to use RestTemplate to retrieve JSON objects and convert them to POJO’s for asserting values in the test. However it turned out that most of the examples online did not deal with this particular scenario or were out of date. So here is how to use Spring 4’s RestTemplate with the latest Apache HTTPClient (version 4.3.1 as of this writing) over HTTPS.

One complication was that the cert was self-signed. This is easily acceptable if using curl with the “-k” option, but with RestTemplate it requires a little more work to accept the cert.

Spring’s RestTemplate integrates with Apache HttpClient, it’s just the HttpClient that needs to be configured with the username, password, and to accept an insecure cert. Here is the code:

1
2
3
4
5
6
7
8
9
10
11
SSLContext sslContext = SSLContexts.custom().loadTrustMaterial(null, new TrustSelfSignedStrategy()).useTLS().build();
SSLConnectionSocketFactory connectionFactory = new SSLConnectionSocketFactory(sslContext, new AllowAllHostnameVerifier());
BasicCredentialsProvider credentialsProvider = new BasicCredentialsProvider();
credentialsProvider.setCredentials(AuthScope.ANY, new UsernamePasswordCredentials("username", "mypassword"));
 
HttpClient httpClient = HttpClientBuilder.create()
                                        .setSSLSocketFactory(connectionFactory)
                                        .setDefaultCredentialsProvider(credentialsProvider)
                                        .build();
 
ClientHttpRequestFactory requestFactory = new HttpComponentsClientHttpRequestFactory(httpClient);

Finally, the request factory is used to construct a new RestTemplate which can make the call to the server.

1
2
3
4
5
RestTemplate template = new RestTemplate(requestFactory);
ResponseEntity<User> response = template.postForEntity("https://localhost:8000/path/to/user/1", "", User.class);
User userResponse = response.getBody();
 
assertEquals(1L, userResponse.getId());

Fortunately the test passes… now we can run integration tests with JUnit at will! Happy Testing!



source - http://thoughtfulsoftware.wordpress.com/2014/01/12/using-resttemplate-with-basic-auth/














'Framework & Platform > Spring' 카테고리의 다른 글

spring - headers="Accept=*/*"  (0) 2014.12.26
spring - Get current ApplicationContext  (0) 2014.10.06
spring - @Autowired @Resource @Qualifier  (0) 2014.09.05
spring data - jpa insert  (0) 2014.08.24
spring data - redis example  (0) 2014.08.15
Posted by linuxism
,


Dependency Injection

특정 Bean의 기능 수행을 위해 다른 Bean을 참조해야 하는 경우 사용하는 Annotation으로는 @Autowired 또는 @Resource가 있다.

  • @Autowired

  • Spring Framework에서 지원하는 Dependency 정의 용도의 Annotation으로, Spring Framework에 종속적이긴 하지만 정밀한 Dependency Injection이 필요한 경우에 유용하다.
  • @Resource

  • JSR-250 표준 Annotation으로 Spring Framework 2.5.* 부터 지원 가능한 Annotation이다. Annotation 사용으로 인해 특정 Framework에 종속적인 어플리케이션을 구성하지 않기 위해서는 @Resource를 사용할 것을 권장한다. @Resource를 사용하기 위해서는 클래스패스 내에 jsr250-api.jar 파일이 추가되어야 함에 유의해야 한다.

다음은 @Resource를 사용한 예이다.

@Service
public UserServiceImpl implements UserService {
    @Resource
    private UserDAO userDAO;
}


@Autowired와 @Resource를 사용할 수 있는 위치는 다음과 같이 약간의 차이가 있으므로 필요에 따라 적절히 사용하면 된다.

  • @Autowired : 필드, 생성자, 입력파라미터가 여러개인 메소드(@Qualifier는 메소드의 파라미터)에 적용 가능
  • @Resource : 필드, 입력 파라미터가 한 개인 빈 프로퍼티 setter 메소드에 적용가능

@Autowired나 @Resource를 필드에 직접 정의하는 경우 별도 setter 메소드는 정의하지 않아도 된다.

Type-driven Injection

@Autowired는 기본적으로 type-driven injection 이다. 타입으로 참조할 빈을 찾았을 때 같은 타입의 빈이 여러 개 검색되었을 경우, @Qualifier annotation을 사용하여 구분할 수 있도록 해준다. 

다음은 @Qualifier를 사용한 예이다.
@Service
public ProductService {
    @Autowired
    @Qualifier("electronics")
    private ProductCategory productCategory;
}
Qualifier를 정의하는 방법에는 다음과 같이 두가지가 있다.
  • XML을 사용한 정의
  • <bean class="anyframe.sample.springmvc.annotation.web.SimpleProductCategory">
        <qualifier value="electronics"/>
        <!-- inject any dependencies required by this bean -->
    </bean>
    
    <bean class="anyframe.sample.springmvc.annotation.web.SimpleProductCategory">
        <qualifier value="cosmetics"/>
        <!-- inject any dependencies required by this bean -->
    </bean>
    		
  • Annotation을 사용한 정의
  • @Component
    @Qualifier("electronics")
    public class ElectronicsProductCategory implements ProductCategory {
    	//...
    }

기본적으로 @Autowired가 적용된 프로퍼티는 필수이기 때문에 반드시 해당 빈이 존재해야 하지만, required 속성을 false로 설정하는 경우에는 해당되는 Bean을 찾지 못하더라도 에러가 발생하지 않는다.
@Service
public UserService implements UserService {
    @Autowired(required=false)
    private UserDAO userDAO;
}

Naming Auto Wired Dependencies

@Resource annotation은 다음과 같은 경우에 사용한다.
  • Bean name으로 Dependency Injection을 하고자 하는 경우
  • Type-driven injection을 할 수 없는 Collection이나 Map 타입의 빈
@Resource를 사용하는 경우 참조되는 Bean은 변수명을 Bean Name으로 하여 Spring 컨테이너에 의해 자동으로 인지되는데, 변수명을 이용하여 참조 관계에 놓인 Bean을 찾았는데 해당 Bean이 없는 경우에는 클래스 타입을 이용하게 된다. 참조 관계에 놓인 Bean의 Name을 직접 명시하고자 하는 경우에는 다음과 같이 'name' 속성을 부여할 수 있다.
@Service
public UserServiceImpl implements UserService {
    @Resource (name="uDAO")
    private UserDAO userDAO;
}

Custom Qualifier

@Autowired annotation을 이용하여 보다 정밀하게 Dependency Injection을 수행할 필요가 있을 경우, Spring Framework의 Custom Qualifier를 사용할 수 있다.
1.Custom Qualifier 정의
다음은 @UserDAOQualifier라는 Custom Qualifier 코드의 일부로 @UserDAOQualifier는 dbtype이라는 속성 정보를 갖고 있다. dbtype 따라 참조해야 할 Bean이 달라지는 경우 즉, DBMS 유형에 따라 다른 데이터 접근 로직이 실행되어야 하는 경우에 사용될 수 있다.
@Target({ElementType.FIELD, ElementType.PARAMETER})
@Retention (RetentionPolicy.RUNTIME)
@Qualifier
public @interface UserDAOQualifier {
    String dbtype();
}
java.lang.annotation.Target은 사용한 Annotation이 어디에 적용될 것인지 Annotation을 선언할 때 정의한다. (예를 들면 클래스나 메소드, 필드 등.) 만약 Target이 정해지지 않으면 어디에서나 사용가능한 Annotation이 된다. java.lang.annotation.Retention은 Annotation을 선언할때 쓰이는데, 다음과 같은 Parameter들이 사용 가능하다.
  • RetentionPolicy.SOURCE : 해당 Annotation이 소스레벨이라는 사실을 알려줌 (default)
  • RetentionPolicy.CLASS : 소스코드와 컴파일된 클래스 파일에는 사용 가능하지만, 런타임에는 사용 불가.
  • RetentionPolicy.RUNTIME : 소스코드, 컴파일된 코드, 런타임에도 사용 가능

2.XML 정의
속성 정의 XML 파일 내에 Custom Qualifer로써 UserDAOQualifier 클래스에 대해 정의하여 특정 클래스에서 해당 Annotation을 사용할 수 있도록 한다.
<bean id="customAutowireConfigurer"
    class="org.springframework.beans.factory.annotation.CustomAutowireConfigurer">
    <property name="customQualifierTypes">
        <set><value>…UserDAOQualifier</value></set>
    </property>
</bean>
다음은 dbtype에 따라 어떤 Bean이 할당될 것인지를 명시하는 부분으로 dbtype이 Oracle일 경우 UserDAOWIthOracle의 인스턴스가 컨테이너에 의해 인지되도록 정의되어 있음을 알 수 있다.
<bean class="...UserDAOWIthOracle">
    <meta key="dbtype" value="oracle"/>
</bean>

3.활용
앞서 정의한 Custom Qualifier @UserDAOQualifier는 다음과 같이 사용한다. 다음의 코드에서 dbtype을 oracle로 정의하고 있으므로, xml 정의에 따라 userDAO라는 변수에는 UserDAOWIthOracle의 인스턴스가 할당될 것이다.
public class UserServiceImpl implements UserService {
    @Autowired
    @UserDAOQualifier(dbtype="oracle")
    private UserDAO userDAO;
    // ...
}



source - http://dev.anyframejava.org/anyframe/doc/core/3.2.0/corefw/guide/annotation-dependencies.html








@Autowired 어노테이션은 의존관계를 자동적으로 설정할때 사용한다. bytype
@Required 어노테이션이 Setter method에 한정되어 사용되는 반면,
@Autowired 어노테이션은 생성자, 메서드(일반메서드 포함), 변수 세곳에 적용이 가능한다.

public class SimpleMovieLister {
//@Autowired
private MovieFinder movieFinder;

@Autowired
public void setMovieFinder(MovieFinder movieFinder) {
this.movieFinder = movieFinder;
}
}


지원하기 위해 빈 설정 잡업 @Required와 같다.
<bean class="org.springframework.beans.factory.annotation.RequireAnnotationBeanPostProcessor" />

or

<context:annotion-config />


@Autowired는 타입을 이용해서 자동적으로 값을 설정하기때문에 해당 타입의 빈 객체가 존재하지 않거나 또는 2개이상 존재할 경우 빈객체를 생성할때 예외를 발생시킨다.

자동적으로 묶기를 원하지 않는 경우에는 @Autowired(required=false) 라고 표시를 해주면 됩니다.

자동적으로 묶기의 최대의 단점은 byType에 오는 애매함이다. 같은 타입이 2개이상 존재할 경우 예외가 발생한다. 이를 보강하기 위해 @Qualifier어노테이션이다.

@Quilifier 

이 어노테이션을 이용하여 동일한 타입의 빈 객체들 중에서 특정 빈을 사용하도록 설정할수 있다.

@Autowired

public void prepre(@Qualifier("car1") Car car, int maxSpeed){

    this.car = car;    //......

}


Car 타입의 빈객체중에서 수식어가 "car1"인 빈 객체를 자동연결한다는 뜻이다. 빈객체의 수식어는 설정 파일에서 <qualifier>태크를 이용하여 설정할수 있다. 

<bean id = "car" class="spring.study.Car">

    <qualifier value = "car1"

</bean>



출처 - http://crystalpark.tistory.com/17








Posted by linuxism
,