Quel type de base de données vais-je obtenir avec une application Apache Wicket?

Question

J'ai donc fait ma conception orientée objet, mis en place un schéma de base de données pour mon design, et promis un délai de livraison incroyablement court. J'ai décidé de me simplifier la vie en utilisant un Framework Web. Le printemps semble incroyablement compliqué (et plutôt inélégant à un coup d'œil superficiel) et Roo est impossible à comprendre et/ou obtenir de l'aide sur les forums au-delà de faire autre chose qu'une application de base de CRUD. J'utilise (et j'apprends!) Wicket pour accomplir ma tâche. Je passe beaucoup de temps à essayer de comprendre comment Wicket crée et utilise la base de données et si je comprends bien, il le fait automagiquement à partir des POJO que je vais créer. Cependant, je crée des objets qui utilisent des objets de façon modérément complexe, et je voudrais avoir une meilleure idée de ce à quoi le résultat final ressemblera dans mySQL.

Est-ce que quelqu'un a des informations ou des liens qui expliquent le schéma résultant de l'application Wicket?

Answer 1

Il me semble que vous venez du monde PHP ou .Net et n'êtes pas habitué à la façon dont les choses fonctionnent en Java (en mettant l'accent sur le travail). En bref: il n'y a pas de repas gratuit et si vous jetez un coup d'œil à Spring ou à Roo et que vous concluez que c'est trop compliqué, vous pourriez avoir des moments difficiles à venir. Java offre beaucoup de cadres et de flexibilité, mais vous devez faire le travail. Cela dit, j'adore Wicket, même s'il a une certaine courbe d'apprentissage. Wicket a une excellente approche pour modéliser et résoudre toutes les logiques métier et de contrôle dans le code Java réel. En outre, Wicket a une communauté active avec une documentation très complète, des wiki et des exemples. Wicket, comme l'a souligné Joril, ne fait rien en relation avec Object Relational Mapping (ORM) ou la persistance en général AFAIK. Il pourrait y avoir des extensions ou des projets liés à Wicket qui offrent quelque chose pour cela.

Voici mes conseils pour vous sur la façon d'aborder ceci: Utilisez Maven2 et printemps (oui, printemps) et importer les dépendances suivantes dans votre pom.xml:

<properties> 
    <spring.version>3.0.0.RELEASE</spring.version> 
    <wicket.version>1.4.10</wicket.version> 
</properties> 

<dependencyManagement> 
<dependency> 
    <groupId>org.springframework</groupId> 
    <artifactId>org.springframework.context</artifactId> 
    <version>${spring.version}</version> 
</dependency> 
<dependency> 
    <groupId>org.springframework</groupId> 
    <artifactId>org.springframework.orm</artifactId> 
    <version>${spring.version}</version> 
</dependency> 
<dependency> 
    <groupId>org.apache.commons</groupId> 
    <artifactId>com.springsource.org.apache.commons.dbcp</artifactId> 
    <version>1.2.2.osgi</version> 
    <scope>runtime</scope> 
</dependency> 
<dependency> 
    <groupId>org.apache.commons</groupId> 
    <artifactId>com.springsource.org.apache.commons.pool</artifactId> 
    <version>1.5.3</version> 
    <scope>runtime</scope> 
</dependency> 
<dependency> 
<groupId>com.mysql.jdbc</groupId> 
    <artifactId>com.springsource.com.mysql.jdbc</artifactId> 
    <version>5.1.6</version> 
</dependency> 
<dependency> 
    <groupId>org.hibernate</groupId> 
    <artifactId>com.springsource.org.hibernate</artifactId> 
    <version>3.3.2.GA</version> 
</dependency> 
<dependency> 
    <groupId>javax.persistence</groupId> 
    <artifactId>com.springsource.javax.persistence</artifactId> 
    <version>1.0.0</version> 
</dependency> 
<dependency> 
    <groupId>org.hibernate</groupId> 
    <artifactId>com.springsource.org.hibernate.annotations</artifactId> 
    <version>3.4.0.GA</version> 
    <exclusions> 
     <exclusion> 
     <groupId>org.apache.commons</groupId> 
     <artifactId>com.springsource.org.apache.commons.logging</artifactId> 
    </exclusion> 
    </exclusions> 
</dependency> 
<dependency> 
    <groupId>org.apache.wicket</groupId> 
    <artifactId>wicket</artifactId> 
    <version>${wicket.version}</version> 
</dependency> 
<dependency> 
    <groupId>org.apache.wicket</groupId> 
    <artifactId>wicket-spring</artifactId> 
    <version>${wicket.version}</version> 
    <exclusions> 
     <exclusion> 
     <artifactId>spring</artifactId> 
     <groupId>org.springframework</groupId> 
    </exclusion> 
    </exclusions> 
</dependency> 
<dependency> 
    <groupId>org.apache.wicket</groupId> 
    <artifactId>wicket-extensions</artifactId> 
    <version>${wicket.version}</version> 
</dependency> 

annoter vos classes de modèle avec JPA/annotations Hibernate comme si (juste un exemple qui montre plusieurs constructions communes):

@Entity(name = "User") 
@Table(name = "users", uniqueConstraints = { @UniqueConstraint(columnNames = { "email" }) }) 
@SecondaryTable(name = "user_picture") 
public class User implements Serializable { 

    @Id 
    @GeneratedValue(strategy = GenerationType.AUTO) 
    private Long id; 
    private String email; 
    private String name; 
    private String password; 
    @Lob 
    @Column(table = "users_picture", length = 524288) 
    private byte[] picture; 
    private Date birthDate; 
    private String phonenumber; 
    @ManyToOne(fetch = FetchType.EAGER) 
    private Address homeAddress; 
    @Enumerated(EnumType.STRING) 
    private Gender gender; 
    @CollectionOfElements(fetch = FetchType.EAGER) 
    @Enumerated(EnumType.STRING) 
    private Set<Weekday> workdays = new HashSet<Weekday>(); 

les hibernate3-maven-plugin pour générer la base de données de vos classes de modèle annotés. Cela permet un immense gain de temps. La base de données est générée pendant la phase de test de maven2. Il existe d'autres plugins (DBUnit) qui vous aident à remplir votre base de données avec des données de test ou similaires (vous pouvez aussi utiliser des scripts old school .sql). Si vous changez quelque chose dans votre modèle, la modification se propage automatiquement à votre base de données (après une construction Maven bien sûr) ce qui est génial pendant le développement.

Ajouter ceci à votre pom (je préfère faire un projet Maven multi-modules avec des modules pour frontend, backend et api, ce qui irait dans votre pom back-end):

<build> 
<plugins> 
<plugin> 
    <groupId>org.codehaus.mojo</groupId> 
    <artifactId>hibernate3-maven-plugin</artifactId> 
    <version>2.0-alpha-1</version> 
    <configuration> 
     <components> 
      <component> 
      <name>hbm2ddl</name> 
      <implementation> 
       annotationconfiguration 
       </implementation> 
     </component> 
     </components> 
     <componentProperties> 
      <drop>true</drop> 
     <jdk5>true</jdk5> 
     <propertyfile> 
      target/classes/jdbc.properties 
      </propertyfile> 
     <skip>${maven.test.skip}</skip> 
     </componentProperties> 
     </configuration> 
     <executions> 
      <execution> 
      <phase>process-test-resources</phase> 
       <goals> 
       <goal>hbm2ddl</goal> 
      </goals> 
      </execution> 
     </executions> 
     <dependencies> 
      <dependency> 
      <groupId>mysql</groupId> 
       <artifactId>mysql-connector-java</artifactId> 
       <version>5.0.5</version> 
     </dependency> 
     </dependencies> 
    </plugin> 
</plugins> 

C'est ce que la table générée ressemblerait à ceci:

+--------------------------------+--------------+------+-----+---------+----------------+ 
| Field       | Type   | Null | Key | Default | Extra   | 
+--------------------------------+--------------+------+-----+---------+----------------+ 
| id        | bigint(20) | NO | PRI | NULL | auto_increment | 
| email       | varchar(255) | YES | UNI | NULL |    | 
| name       | varchar(255) | YES |  | NULL |    | 
| password      | varchar(255) | YES |  | NULL |    | 
| birthDate      | datetime  | YES |  | NULL |    | 
| phonenumber     | varchar(255) | YES |  | NULL |    | 
| gender       | varchar(255) | YES |  | NULL |    | 
| address      | bigint(20) | YES | MUL | NULL |    | 
+--------------------------------+--------------+------+-----+---------+----------------+ 

(users_workdays et users_picture sont des tables secondaires se rapportant à cette entité)

Tous mes exemples sont basés sur l'utilisation d'un Base de données MySQL; vous pouvez le remplacer par un ancien SGBDR.

J'espère que cela vous aide a) à se réveiller et sentir les cendres, b) obtenir votre projet Wicket à la vitesse ORM-sage

acclamations!

Answer 2

Il a été 2+ ans que j'utilisais Wicket, mais autant que je sache, il ne gère pas la persistance du tout .. Alors que Wicket est un très bon à mon humble avis cadre, vous devez gérer la base de données vous superposer avec Hibernate ou certains ORM (ou pas ORM du tout, bien sûr)

Answer 3

Si vous n'êtes pas bloqué dans MySQL, vous pouvez également envisager certains des so-called noSQL databases là-bas. Wicket est formidable à faire les choses de manière orientée objet, et si vous ne créez pas une application d'entreprise qui nécessite des tas de personnes déjà formées à des technologies spécifiques comme MySQL, vous pouvez réduire considérablement votre coût total de possession en ne prenant pas le Chemin SQL.