J1Brasil: Persistência de Dados além do JPA, ou Como usar noSQL em Java

J1Brasil
Persistência de Dados além do JPA,
ou Como usar noSQL em Java

Alexandre Porcelli
alexandre.porcelli@gmail.com

segunda-feira, 13 de dezembro de 2010

Java One Brasil 2010

Alexandre Porcelli
Founder

Alexandre Porcelli
Writer

Alexandre Porcelli
Organizer

Alexandre Porcelli
Commiter / Parser Developer

Alexandre Porcelli
Creator &
Project Lead


JDBC


!
public class Pessoa { ComboPooledDataSource ds = new ComboPooledDataSource();
private int id; try {
private String nome; ds.setDriverClass("com.mysql.jdbc.Driver");

O
private String email; ds.setJdbcUrl("jdbc:mysql://localhost:3306/j1br");
private String telefone; ...
... } catch (PropertyVetoException e) {

G
} throw new RuntimeException(e);
}

I
String nome = "Alexandre Porcelli";
String email = "alexandre.porcelli@gmail.com";

D
String telefone = "+55 11 1234-5678";

Connection conn = null;

Ó
try {
conn = ds.getConnection();
PreparedStatement st = conn.prepareStatement(

C
"INSERT INTO PESSOA (nome, email, telefone) VALUES (?, ?, ?)",
Statement.RETURN_GENERATED_KEYS);
st.setString(1, nome);
st.setString(2, email);

O
st.setString(3, telefone);
st.executeUpdate();
conn.commit();

T
st.getGeneratedKeys().next();

I
Pessoa novaPessoa = new Pessoa(st.getGeneratedKeys().getInt(1),
nome, email, telefone);
} catch (Exception e) {

U
throw new RuntimeException("Pessoa insert failed.", e);
} finally {
try {
if (conn != null) {

M
conn.close();
}
} catch (SQLException e) {
throw new RuntimeException("Can't close connection", e);
}
}


JPA


@RunWith(Arquillian.class)
@Entity
public class PessoaTestCase {
public class Pessoa {
@Deployment
@Id public static Archive<?> createDeployment() {
@GeneratedValue return ShrinkWrap.create(WebArchive.class, "test.war")
private int id; .addPackage(Game.class.getPackage())
private String nome; .addManifestResource("test-persistence.xml", "persistence.xml")
private String email; .addWebResource(EmptyAsset.INSTANCE, "beans.xml");
private String telefone; }
...
} @PersistenceContext
EntityManager em;

@Inject
UserTransaction utx;

@Test
public void insertSampleRecords() throws Exception {
utx.begin();

OK!
em.joinTransaction();

Pessoa novaPessoa = new Pessoa();
novaPessoa.setNome("Alexandre Porcelli");
novaPessoa.setTelefone("+55 11 1234-5678");
novaPessoa.setEmail("alexandre.porcelli@gmail.com");
em.persist(novaPessoa);
System.out.println(novaPessoa);

utx.commit();
}
}

noSQL


hype


problemas do

dia-a-dia


OLTP

On-line Transaction Processing is characterized by a large number of
short on-line transactions (INSERT, UPDATE, DELETE). The main emphasis
for OLTP systems is put on very fast query processing, maintaining data
integrity in multi-access environments and an effectiveness measured by
number of transactions per second.

segurança
autenticação


JAAS, LDAP,
OAUTH...


public boolean isValid(String nomeUsuario, String passw) {
PreparedStatement st;
Connection conn = null;
try {
conn = dataSource.getConnection();
st = conn.prepareStatement("SELECT 1 FROM USERS WHERE id = ? and passw = ?");
st.setString(1, nomeUsuario);
st.setString(2, passw);
ResultSet rs = st.executeQuery();
if (rs.next()) {
return true;
}
return false;
return false;
} finally {
try {
if (conn != null) {
conn.close();
}
throw new RuntimeException("Can't close connection", e);
}
}
}


Estrura de Dados: Chave-Valor
Durabilidade: In-Memory / Serialização Paralela / Réplica
Site: http://redis.io/
Escrito em: C
+ Baixa Latência
+ Serialização Paralela
Pontos Positivos:
+ Estruturas de Dados
+ Cases

Pontos Negativos: o/


public class SegurancaRedisCode {

public static void main(String[] args) {
SegurancaRedisCode seg = new SegurancaRedisCode();
seg.addUserPassw("porcelli", "1234");
Assert.assertTrue(seg.isValid("porcelli", "1234"));
Assert.assertFalse(seg.isValid("porcelli", "123"));
Assert.assertFalse(seg.isValid("xxx", "1234"));
}

private final Jedis jedis;

public SegurancaRedisCode() {
jedis = new Jedis("localhost");
}

public boolean isValid(String nomeUsuario, String passwd) {
String correctPassw = jedis.get("user:" + nomeUsuario + ":passwd");
if (correctPassw != null && passwd.equals(correctPassw)) {
return true;
} else {
return false;
}
}
public void addUserPassw(String nomeUsuario, String passwd) {
jedis.set("user:" + nomeUsuario + ":passwd", passwd);
jedis.save();
}
}

árvore


@Entity
@Table(name = "categorias")
public class Categoria {

@Id
@GeneratedValue
private Integer id;

private String nome;

@OneToMany
@OrderColumn
@JoinColumn(name = "parent_id")
private List<Categoria> filhos = new LinkedList<Categoria>();

@ManyToOne(fetch = FetchType.LAZY)
@JoinColumn(name = "parent_id", insertable = false, updatable = false)
private Categoria parent;
....
}


Estrura de Dados: Grafo
Durabilidade: Single Node
Site: http://neo4j.org
Escrito em: Java
+ ACID
+ Maturidade
Pontos Positivos:
+ Velocidade no Traverse
+ Suporte RDF & SPARQL

Pontos Negativos: - Falta de Sharding


private static enum TipoRelacionamento implements RelationshipType {
PAI
}

private final GraphDatabaseService graph;
private static final String NEO4J_PATH = "sample/tree";

public Neo4jSampleCode() {
graph = new EmbeddedGraphDatabase(NEO4J_PATH);
}

public Node novaCategoria(String nome, Node pai) {
Transaction tx = graph.beginTx();
try {
Node newCat = graph.createNode();
newCat.setProperty("nome", nome);
if (pai != null) {
pai.createRelationshipTo(newCat, TipoRelacionamento.PAI);
}
tx.success();
return newCat;
} finally {
tx.finish();
}
}


public Node getPai(Node node) {
Node result;
try {
Iterable<Relationship> relationships = node.getRelationships(
TipoRelacionamento.PAI, Direction.INCOMING);

if (relationships.iterator().hasNext()) {
result = relationships.iterator().next().getStartNode();
} else {
result = null;
}

tx.success();
return result;
} finally {
tx.finish();
}
}


public List<Node> getFilhos(Node pai) {
List<Node> result = new LinkedList<Node>();
try {
Iterable<Relationship> relationships = pai.getRelationships(
TipoRelacionamento.PAI, Direction.OUTGOING);

for (Relationship relationship : relationships) {
result.add(relationship.getEndNode());
}

tx.success();
return result;
} finally {
tx.finish();
}
}


public List<Node> getArvoreCompleta(Node pai) {
List<Node> result = new LinkedList<Node>();
try {

Traverser traverser = pai.traverse(Order.BREADTH_FIRST,
StopEvaluator.END_OF_GRAPH,
ReturnableEvaluator.ALL_BUT_START_NODE,
TipoRelacionamento.PAI, Direction.OUTGOING);

for (Node node : traverser) {
result.add(node);
}

tx.success();
return result;
} finally {
tx.finish();
}
}


public static void main(String[] args) {
Neo4jSampleCode sample = new Neo4jSampleCode();
Node roupasCat = sample.novaCategoria("Vestuário", null);
Node camisaCat = sample.novaCategoria("Camisas", roupasCat);
Node calcasCat = sample.novaCategoria("Calças", roupasCat);
Node eletronicosCat = sample.novaCategoria("Estronicos", null);

Assert.assertNull(sample.getPai(eletronicosCat));
Assert.assertNotNull(sample.getPai(calcasCat));
Assert.assertEquals(sample.getPai(calcasCat), roupasCat);
Assert.assertNotNull(sample.getPai(camisaCat));
Assert.assertEquals(sample.getPai(camisaCat), roupasCat);
Assert.assertEquals(0, sample.getFilhos(camisaCat).size());
Assert.assertEquals(2, sample.getFilhos(roupasCat).size());
for (Node childCat : sample.getFilhos(roupasCat)) {
if (!childCat.equals(camisaCat) && !childCat.equals(calcasCat)) {
Assert.fail();
}
}

Node camisaMangaCurtaCat = sample.novaCategoria("Manga Curta", camisaCat);
Node camisaMangaLongCat = sample.novaCategoria("Manga Longa", camisaCat);
Assert.assertEquals(4, sample.getArvoreCompleta(roupasCat).size());
for (Node childCat : sample.getFilhos(roupasCat)) {
if (!childCat.equals(camisaCat) && !childCat.equals(calcasCat)
&& !childCat.equals(camisaMangaLongCat)
&& !childCat.equals(camisaMangaCurtaCat)) {
Assert.fail();
}
}
}

produtos
diversidade & irregularidade


nome effective java tv led 32” mesa de madeira mod

valor R$ 80 R$ 1234 R$ 503

um dos melhores livros
descr. tv de led 32” muito boa! mesa de canto legal
sobre java!

qtd. páginas 300 X X

técnico/tecnologia/
categoria X X
programação/java

cons. energia X A X

cor X X marrom claro

dimensão X X 20x40x90


? oo ||relacional ?


Estrura de Dados: Documento
Durabilidade: Réplica
Site: http://mongodb.org
Escrito em: C++
+ Velocidade
+ Index
Pontos Positivos:
+ Consultas ad-hoc
+ Auto Sharding

- Durabilidade
Pontos Negativos: - Update in Place
Google: mongodb and fourquare


private final DB db;

public MongoDBSampleCode() throws UnknownHostException, MongoException {
Mongo mongo = new Mongo();
db = mongo.getDB("MeuDatabase");
db.getCollection("produtos").drop();
}

public void novoEletronico(int id, String nome, int valor,
String descricao, String consumoEnergia) {
DBCollection coll = db.getCollection("produtos");

DBObject dados = new BasicDBObject();
dados.put("id", id);
dados.put("nome", nome);
dados.put("valor", valor);
dados.put("tipo", "eletronico");
dados.put("desc", descricao);
dados.put("cons_energia", consumoEnergia);

coll.insert(dados);
}


public void getProdutosPorValorMenorQue(int valor) {
DBCollection coll = db.getCollection("produtos");

DBObject query = new BasicDBObject();
query.put("valor", new BasicDBObject("$lt", valor));

for (DBObject foundDoc : coll.find(query)) {
System.out.println(foundDoc);
}
}


public static void main(String[] args) throws UnknownHostException,
MongoException {
MongoDBSampleCode samp = new MongoDBSampleCode();
samp.novoEletronico(1, "tvled32", 1234, "Tv de led 32"", "A");
samp.novoEletronico(2, "geladeira", 2030, "Geladeira Duas portas", "B");
samp.novoLivro(3, "effective java", 80,
"um dos melhores livros sobre java!",
"técnico/tecnologia/programação/java", 300);
samp.novoLivro(4, "senhor dos anéis 2", 23, "clássico",
"romance/ficção", 300);
samp.novoMovel(5, "mesa de madeira", 503, "mesa de canto legal",
"clara", "20x40x90");
samp.getProdutosPorValorMenorQue(600);
}


{
"id": 3,
"nome": "effective java",
"valor": 80,
"tipo": "livro",
"desc": "um dos melhores livros sobre java!",
"categoria": "técnico/tecnologia/programação/java",
"qtd_pgs": 300
}

{
"id": 4,
"nome": "senhor dos anéis 2",
"valor": 23,
"tipo": "livro",
"desc": "clássico",
"categoria": "romance/ficção",
"qtd_pgs": 300
}

{
"id": 5,
"nome": "mesa de madeira",
"valor": 503,
"tipo": "movel",
"desc": "mesa de canto legal",
"cor": "clara",
"dimensao": "20x40x90"
}

cache + db
bigdata & latência


Big Data


mas fora do #trendtopic...

1.000.000 tx/hora

100tx/seg.


no início...

Código Banco de Dados


depois...
CACHE

Código Banco de Dados


Estrura de Dados: Família de Colunas
Durabilidade: Réplica
Site: http://cassandra.apache.org
Escrito em: Java

+ Conceito Dynamo & Big-Table
Pontos Positivos: + Escalabilidade
+ Conﬁguração

Pontos Negativos: Google: cassandra & digg


modelo


exemplo...

Keyspace: Keyspace1

Família de Colunas: Standard1
nome
chave valor timestamp
da coluna
porcelli telefone 1234-5678 1291325256 ...


final private CassandraClientPool pool;

public CassandraSampleCode() {
pool = CassandraClientPoolFactory.INSTANCE.get();
}

public void novoDado(String nomeUsuario, String telefone, String email) {
CassandraClient client = null;
try {
client = pool.borrowClient("localhost", 9160);

Keyspace keyspace = client.getKeyspace("Keyspace1");
ColumnPath columnPath = new ColumnPath();
columnPath.setColumn_family("Standard1");
columnPath.setColumn(bytes("telefone"));
keyspace.insert(nomeUsuario, columnPath, bytes(telefone));

columnPath.setColumn(bytes("email"));
keyspace.insert(nomeUsuario, columnPath, bytes(email));
} finally {
pool.releaseClient(client);
}
}


public String getTelefone(String nomeUsuario) {
CassandraClient client = null;
try {
client = pool.borrowClient("localhost", 9160);

Keyspace keyspace = client.getKeyspace("Keyspace1");
ColumnPath columnPath = new ColumnPath();
columnPath.setColumn_family("Standard1");
columnPath.setColumn(bytes("telefone"));
Column colValue = keyspace.getColumn(nomeUsuario, columnPath);
return string(colValue.getValue());
} catch (NotFoundException e) {
return null;
} finally {
pool.releaseClient(client);
}
}


public static void main(String[] args) throws Exception {
CassandraSampleCode samp = new CassandraSampleCode();
Assert.assertNull(samp.getTelefone("porcelli"));
Assert.assertNull(samp.getEmail("porcelli"));
samp.novoDado("porcelli", "+55 11 1234-5678", "alexandre.porcelli@gmail.com");
Assert.assertEquals("+55 11 1234-5678", samp.getTelefone("porcelli"));
Assert.assertEquals("alexandre.porcelli@gmail.com", samp.getEmail("porcelli"));
}


busca


SELECT *
FROM
PRODUTO
WHERE
NOME LIKE “TE%”


Estrura de Dados: Lista Invertida
Durabilidade: Single Node
Site: http://lucene.apache.org
Escrito em: Java

+ Baixa Latência
Pontos Positivos: + Durabilidade
+ Padrão

Pontos Negativos: o/


OLAP

On-line Analytical Processing is characterized by relatively low volume
of transactions. Queries are often very complex and involve
aggregations. For OLAP systems a response time is an effectiveness
measure. OLAP applications are widely used by Data Mining techniques.


persistência
poliglota


quer saber mais?


Perguntas?

@porcelli

Código Fonte https://github.com/porcelli/j1brasil-sample-code


Obrigado

@porcelli

github.com/porcelli

about.me/porcelli porcelli.com.br

alexandre.porcelli@gmail.com

linkedin.com/in/alexandreporcelli

J1Brasil: Persistência de Dados além do JPA, ou Como usar noSQL em Java

Recommended

Recommended

More Related Content

What's hot

What's hot (19)

Similar to J1Brasil: Persistência de Dados além do JPA, ou Como usar noSQL em Java

Similar to J1Brasil: Persistência de Dados além do JPA, ou Como usar noSQL em Java (11)

More from Alexandre Porcelli

More from Alexandre Porcelli (20)

Recently uploaded

Recently uploaded (6)

J1Brasil: Persistência de Dados além do JPA, ou Como usar noSQL em Java