Arquivo da tag: Principal

Evitando erro de “Wrong permissions on configuration file” no XAMPP

Muita gente(inclusive eu…), após instalar o XAMPP no seu linux, altera as permissões de todos os arquivos do XAMPP e deixa tudo com permissão total para todos (777). E na hora de dar um “start” no serviço mysql ou acessar o phpMyAdmin recebe uma bela mensagem que diz “Wrong permissions on configuration file, should not be world writable!”.

Que bonito!! É uma bela reclamação para o nosso chmod com permissão 777. E agora, como arrumar isso??

Não sei o seu caso, mas para mim foi simples. Ao iniciar, o phpMyAdmin necessita que pelo menos dois arquivos não estejam editáveis. São eles: “config.inc.php” e “my.cnf”. Para resolver, dei permissão 644 para esses dois arquivos e … feitooooo!!! O phpMyAdmin voltou a funcionar.

Por hoje é só, pessoal! Até a próxima.

Disponibilizando ViewScope para Spring

spring e jsf

Quem trabalha com JSF sabe que existem escopos para seus Managed Beans, e que eles devem ser bem definidos conforme o papel de cada Managed Bean na aplicação. Esse tal de “escopo” define o tempo de vida desse objeto(o Managed Bean) dentro da aplicação.

A partir do JSF 2.0 foi implementado um novo tipo de escopo, chamado de ViewScope. Este novo escopo veio para suprir a necessidade de se ter um tempo de vida dos Managed Beans um pouco maior do que o Request e menor que o Session. O uso do ViewScope é muito recomendado pois evita que um ManagedBean fique instanciado durante a sessão inteira do usuário(caso do SessionScope) mesmo que não esteja mais sendo usado, e possibilita guardar dados enquanto o usuário não troca de página(UIViewRoot), mesmo utilizando requisições ajax(o que não é possível com o RequestScope).

Grande parte das aplicações possuem frameworks, como o Spring, para gerenciar seus Beans. Logicamente, devem ser utilizadas as configurações do framework para o gerenciamento dos mesmos. No caso do Spring, (ainda) não existe um escopo com a mesma lógica do ViewScope do JSF, mas como todo bom framework, pode-se customizar um tipo de escopo e fazer uso dele normalmente na aplicação. É claro que para isso é necessário implementá-lo.

Na empresa onde trabalho utilizamos Spring e tivemos a necessidade de modificar alguns escopos de Session para View. Encontramos um post(em inglês) que fala sobre isso e exemplifica como implementar e disponibilizar um “ViewScope” para o Spring.

Segue aí os passos para implementar seu ViewScope para o Spring.

1. Implementar a classe responsável pelo gerenciamento dos Beans:

import java.util.Map;

import javax.faces.context.FacesContext;

import org.springframework.beans.factory.ObjectFactory;
import org.springframework.beans.factory.config.Scope;
import org.springframework.web.context.request.FacesRequestAttributes;

public class ViewScope implements Scope {

	public static final String VIEW_SCOPE_CALLBACKS = "viewScope.callbacks";

	public synchronized Object get(String name, ObjectFactory<?> objectFactory) {
		Object instance = getViewMap().get(name);
		if (instance == null) {
			instance = objectFactory.getObject();
			getViewMap().put(name, instance);
		}
		return instance;
	}

	public Object remove(String name) {
		Object instance = getViewMap().remove(name);
		if (instance != null) {
			Map<String, Runnable> callbacks = (Map<String, Runnable>) getViewMap().get(VIEW_SCOPE_CALLBACKS);
			if (callbacks != null) {
				callbacks.remove(name);
			}
		}
		return instance;
	}

	public void registerDestructionCallback(String name, Runnable runnable) {
		Map<String, Runnable> callbacks = (Map<String, Runnable>) getViewMap().get(VIEW_SCOPE_CALLBACKS);
		if (callbacks != null) {
			callbacks.put(name, runnable);
		}
	}

	public Object resolveContextualObject(String name) {
		FacesContext facesContext = FacesContext.getCurrentInstance();
		FacesRequestAttributes facesRequestAttributes = new FacesRequestAttributes(facesContext);
		return facesRequestAttributes.resolveReference(name);
	}

	public String getConversationId() {
		FacesContext facesContext = FacesContext.getCurrentInstance();
		FacesRequestAttributes facesRequestAttributes = new FacesRequestAttributes(facesContext);
		return facesRequestAttributes.getSessionId() + "-" + facesContext.getViewRoot().getViewId();
	}

	private Map<String, Object> getViewMap() {
		return FacesContext.getCurrentInstance().getViewRoot().getViewMap();
	}
}

2. Para poder “destruir” o Bean é necessário colocá-lo em algum local em que seja possível recuperá-lo posteriormente. A classe acima implementa o método registerDestructionCallback, responsável por registrar uma chamada de destruição ao Bean. Essa chamada será armazenada no viewMap da ViewRoot(nossa página que será mostrada), dentro de um Map para que possamos acessá-lo através de uma chave que será o nome do Bean. Graças ao mecanismo de Listeners, conseguimos inserir um novo objeto(no nosso caso um novo Map) dentro do viewMap da página.

Com a implementação da classe abaixo estaremos tratando de dois eventos simultaneamente: assim que o viewMap é construído(na inicialização da página ou PostConstructViewMapEvent) inserimos nosso “repositório” de Beans com ViewScope e seus respectivos destrutores, que será utilizado pelo método registerDestructionCallback, e pouco antes dele ser destruído(PreDestroyViewMapEvent) resgatamos os Beans com ViewScope inseridos no nosso “repositório” criado anteriormente e chamamos seus destrutores.

import java.util.HashMap;
import java.util.Map;

import javax.faces.component.UIViewRoot;
import javax.faces.event.AbortProcessingException;
import javax.faces.event.PostConstructViewMapEvent;
import javax.faces.event.PreDestroyViewMapEvent;
import javax.faces.event.SystemEvent;
import javax.faces.event.ViewMapListener;

public class ViewScopeCallbackRegistrer implements ViewMapListener {

	public void processEvent(SystemEvent event) throws AbortProcessingException {
		if (event instanceof PostConstructViewMapEvent) {
			PostConstructViewMapEvent viewMapEvent = (PostConstructViewMapEvent) event;
			UIViewRoot viewRoot = (UIViewRoot) viewMapEvent.getComponent();
			viewRoot.getViewMap().put(ViewScope.VIEW_SCOPE_CALLBACKS, new HashMap<String, Runnable>());
		} else if (event instanceof PreDestroyViewMapEvent) {
			PreDestroyViewMapEvent viewMapEvent = (PreDestroyViewMapEvent) event;
			UIViewRoot viewRoot = (UIViewRoot) viewMapEvent.getComponent();
			Map<String, Runnable> callbacks = (Map<String, Runnable>) viewRoot.getViewMap().get(ViewScope.VIEW_SCOPE_CALLBACKS);
			if (callbacks != null) {
				for (Runnable c : callbacks.values()) {
					c.run();
				}
				callbacks.clear();
			}
		}
	}

	public boolean isListenerForSource(Object source) {
		return source instanceof UIViewRoot;
	}
}

3. Disponibilizar a nossa classe ViewScope para o Spring, inserindo o código abaixo no seu applicationContext.xml:

<bean class="org.springframework.beans.factory.config.CustomScopeConfigurer">
    <property name="scopes">
        <map>
            <entry key="view">
                <bean class="seupackage.ViewScope"/>
            </entry>
        </map>
    </property>
</bean>

4. Registrar nossa classe ViewScopeCallbackRegistrer nos listeners do Faces, inserindo o código abaixo no faces-config.xml:

<system-event-listener>
    <system-event-listener-class>seuPackage.ViewScopeCallbackRegistrer</system-event-listener-class>
    <system-event-class>javax.faces.event.PostConstructViewMapEvent</system-event-class>
    <source-class>javax.faces.component.UIViewRoot</source-class>
</system-event-listener>

<system-event-listener>
    <system-event-listener-class>seuPackage.ViewScopeCallbackRegistrer</system-event-listener-class>
    <system-event-class>javax.faces.event.PreDestroyViewMapEvent</system-event-class>
    <source-class>javax.faces.component.UIViewRoot</source-class>
</system-event-listener>

Basta agora utilizar a anotação @Scope(“view”) sobre seus Managed Beans e eles passarão a ter o comportamento do @ViewScope, mas agora gerenciados pelo Spring.

Bons códigos!!!

Fonte: http://www.harezmi.com.tr/spring-view-scope-for-jsf-2-users/

Manipulação de String em Java

Com exceção dos tipos primitivos, todos os tipos de valores utilizados em Java são objetos. Um dos objetos mais utilizados por programadores, experientes ou novatos, é o tipo String. No tipo String podem ser gravados vários dados distintos em apenas um objeto, como: letras, números e caracteres especiais (@,#$%&*!). Para a declaração, lembrando que String é um objeto, temos duas maneiras, uma é como uma variável normal, e outra, como um construtor.

//declaracao como variavel normal
String s;
String s1 = "String 1";
//declaracao como contrutor
String s2 = new String();
s = new String("Outra String");

Existem inumeros métodos que podem ser utilizados para fazer a manipulação de String. Para quem já tem uma certa experiência este tipo de manipulação já é mais comum e fácil de ser entendido, mas para iniciantes, certamente terão algumas dificuldades e os métodos a seguir demonstrados poderão resolver alguns problemas no uso de String.

Método lenght: retorna um inteiro com o tamanho do String, ou seja, retorna o número de caracteres da variável.

//o metodo retorna um inteiro
int tamanho = s.length();

Método charAt: retorn um char com o caracter de uma posição especifica do String.

//pega o caracter na posicao 2 do String
char c = s.charAt(2);

Método equals: retorna um boolean, true se dois Strings são iguais, ou false se são diferentes.

//verifica se s1 e s2 sao iguais
String s1 = "String";
String s2 = "String";
if(s1.equals(s2)){
     System.out.println("sao iguais");
}

Método equalsIgnoreCase: verifica se dois Strings são iguais, sem levar-se em consideração se os caracteres são maiúsculos ou minúsculos.

//verifica se s1 e s2 sao iguais
String s1 = "String";
String s2 = "string";
if(s1.equals(s2)){
     System.out.println("sao iguais");
}

Método compareTo: retorna 0 (zero) se o String que chama o método for igual ao String passado como parâmetro, retorna um valor negativo se o String que chama o método for menor que o String do parâmetro, e um valor positivo se o String que chama o método for maior que a String do parâmetro.

//compareTo bastante usado para ordenar strings
String s1 = "b";
String s2 = "a";
if(s1.compareTo(s2)==0){
     System.out.println("sao iguais");
}else if(s1.compareTo(s2)<0){
     System.out.println("s2 é maior");
}else if(s1.compareTo(s2)>0){
     System.out.println("s1 é maior");
}

Método compareToIgnoreCase: tem os mesmos retornos do compareTo, a diferença é que neste não é levado em consideração os caracteres maiúsculos.

 

String s1 = "A";
String s2 = "a";
if(s1.compareTo(s2)==0){
     System.out.println("sao iguais");
}

Método substring: retorna um String, com os caracteres de um determinado trecho passado por parâmetro.

String s1 = "abcdefghijkl";
//no exemplo a seguir o trecho determinado 
//vai da posicao 3 até o fim do String 
String s2 = s1.substring(3);
System.out.println(s2);

//no exemplo a seguir o trecho determinado
//vai da posicao 3 ate a posicao 6
s2 = s1.substring(3,6);
System.out.println(s2);

Método replace: faz a substituição de determinado caracter por outro.

 

String s1 = "a";
String s2 = s1.replace("a","A");
System.out.println(s2);

Método indexOf: retorna um inteiro com a posição onde aparece pela primeira vez um determinado caracter.

String s1 = "aaabaaa";
int posicao = s1.indexOf("b");
System.out.println(posicao);

Método lastIndexOf: semelhante ao indexOf, só que retorna a última vez que aparece determinado caracter.

 

String s1 = "aaababa";
int posicao = s1.indexOf("b");
System.out.println(posicao);

Método toUpperCase: retorna uma nova String, mas transforma todos os caracteres para maiúsculos.

String s1 = "aaaaa";
String s2 = s1.toUpperCase();
System.out.println(s2);

Método toLowerCase: retorna nova String, mas transforma os caracteres em minúsculos.

String s1 = "AAAAA";
String s2 = s1.toLowerCase();
System.out.println(s2);

Método trim: retorna nova String, mas faz uma limpeza de espaços em branco no inicio e no fim da String.

String s1 = "   aaa ";
String s2 = s1.trim();
System.out.println(s2);

Método startsWith: retorna true caso o valor do String se inicie com determinada sequência de caracteres.

String s1 = "abcdefg";
if(s1.startsWith("ab")){
     System.out.println("inicia com ab");
}else{
     System.out.println("nao inicia com ab");
}

Método endsWith: retorna true caso o valor do String se encerre com determinada sequência de caracteres.

String s1 = "abcdefg";
if(s1.endsWith("fg")){
     System.out.println("inicia com fg");
}else{
     System.out.println("nao inicia com fg");
}

Bom, estes são os principais métodos para manipulação de Strings, com exemplos bem simples de entender, espero ter ajudado aos iniciantes na arte de programar em Java, e qualquer dúvida, sugestão, críticas, podem entrar em contato conosco. Obrigado e viva o Java.

Conheça a Tecnologia JAVA

Até hoje, a plataforma Java já atraiu mais de 6,5 milhões de desenvolvedores de software. É utilizada em todos os principais segmentos da indústria, estando presente em uma ampla gama de dispositivos, computadores e redes.

Sua versatilidade, eficiência, portabilidade de plataforma e segurança fazem dela a tecnologia ideal para a computação em rede. A tecnologia Java está em todo lugar! Ela pode ser encontrada em laptops, datacenters, consoles de jogo, supercomputadores científicos, telefones celulares e até na Internet.

A tecnologia Java está presente em mais de 4,5 bilhões de dispositivos, incluindo:

  • Mais de 800 milhões de PCs
  • 2,1 bilhões de telefones celulares e outros dispositivos portáteis (fonte: Ovum)
  • 3,5 bilhões de cartões inteligentes
  • Além de set-top boxes, impressoras, webcams, jogos, sistemas de navegação para automóveis, terminais lotéricos, dispositivos médicos, guichês de pagamento de estacionamento etc.

Para conhecer os locais de aplicação do Java in Action em sua vida diária, explore o site java.com.

Por que os desenvolvedores de software preferem o Java

O Java foi testado, refinado, ampliado e experimentado por uma comunidade dedicada. E, com mais de 6,5 milhões de desenvolvedores, é a tecnologia mais ampla e ativa do planeta. Com sua versatilidade, eficiência e portabilidade, o Java tem valor inestimável para desenvolvedores, pois permite:

  • Criar um software em uma plataforma e executá-lo em praticamente qualquer outra
  • Criar programas para execução em navegadores e serviços da Web
  • Desenvolver aplicativos no lado do servidor usados tanto em fóruns, lojas e pesquisas on-line, como no processamento de formulários HTML, e muito mais
  • Combinar aplicativos ou serviços usando a linguagem Java para criar aplicativos ou serviços altamente personalizados
  • Criar aplicativos potentes e eficazes para telefones celulares, processadores remotos, produtos de consumo de baixo custo e praticamente qualquer outro dispositivo com tecnologia digital

Algumas maneiras para que os desenvolvedores de software aprendam o Java

Atualmente, várias faculdades e universidades oferecem cursos de programação para a plataforma Java. Além disso, os desenvolvedores também podem aprimorar suas habilidades em programação Java lendo o site java.sun.com da Oracle, assinando os boletins informativos baseados na tecnologia Java, usando o Tutorial do Java e o Programa Principiante no Centro Java e ingressando em cursosWeb, virtuais ou ministrados por um instrutor

 

Fonte: Artigo retirado de: http://www.java.com/pt_BR/ acessado em: 08/06/2011