En el artículo anterior, hemos completado la implementación del menú EasyUI. Haga clic aquí para verlo. En esta sección, escribiremos principalmente sobre la clase de implementación CategoryServiceImpl para completar la consulta en cascada de la base de datos. En general, el proyecto se realiza desde la parte posterior hasta el frente, primero hagamos el servicio (no extraemos DAO y finalmente se extraemos), y luego hacemos la capa superior después de terminar.
Antes de escribir, echemos un vistazo a las tablas de la base de datos:
Drop Base de datos si existe la tienda; /*Crear base de datos y establecer codificación*/ Crear base de datos Tienda de caracteres predeterminado Conjunto de caracteres UTF8; usar tienda; /*Eliminar tabla de administrador*/ Tabla de caída si existe cuenta; /*Eliminar Tabla de categoría de producto*/ Tabla de caída si existe; /*=================================================================================================================================================================. ================================================================================================================ =======================================================================================================================================================================================================================================================================================. ================================================================================================================ Nombre de inicio de sesión del administrador*/ Login Varchar (20),/*Nombre del administrador*/ Name varchar (20),/*contraseña de administrador*/ pasar varchar (20)); /*==================================================================================================================== S ================================================================================================================== ================================================================================================================== =========================================================================================================================================================================================== S False, /* Clave extranjera, qué administrador administra esta categoría* / Account_id int, restricción AID_FK Clave extranjera (Account_ID) Cuenta de referencias (id));
Hay principalmente dos tablas, la tabla de categoría de productos y la tabla de administrador, y se proporciona una tabla de administrador asociada a la clave extranjera en la tabla de categoría de productos. Es decir, el producto y el administrador son una relación de muchos a uno. Ahora comenzamos a escribir información de categoría para consultar productos, y necesitamos un administrador en cascada.
1. Implementar el método de consulta en cascada
Primero, defina este método en la interfaz CategorialService:
Interfaz pública CategyService extiende BasesService <Cateatory> {// Información de categoría de consulta, en cascada la lista pública del administrador <Catherory> QueryjoinAccount (tipo de cadena); // Consulta con el nombre de la categoría} Luego implementamos este método en la clase de implementación CategyServiceImpl de CategoryService:
@Service ("CategoryService") Clasificación pública CategyServiceImpl extiende BaseServiceImpl <Category> Implementa CategyService {@Override Public List <Cateatory> QueryjoinAccount (Tipo de cadena) {String Hql = "de la categoría C donde C.Type me gusta: Tipo"; return getSession (). CreateQuery (HQL) .SetString ("Tipo", "%" + Tipo + "%"). List (); }} Entre los dos modelos, asignaremos un enlace a la anotación:
// @ManyToOne (fetch = fetchType.eager) @Joincolumn (name = "Account_id") Cuenta pública getAccount () {return this.account; } // @Onetomany (cascade = cascadeType.all, fetch = fetchtype.lazy, mappedby = "cuenta") conjunto público <ategorial> getCategories () {return this.Categories; } Luego lo probamos en la clase de prueba:
@RunWith (SpringJunit4ClassRunner.class) @ContextConfiguration (ubicaciones = "classpath: beans.xml") Categoría de clase públicaServiceImplTest {@Resource Categoría privada Categoría de servicio; @Test public void testQueryjoinAccount () {for (categoría c: categoryService.QueryjoinAccount ("" ")) {System.out.println (c); System.out.println (c.getAccount ()); }}} 2. Problemas con consultas en cascada
Si observamos la salida de la consola, podemos ver que ha enviado más de una declaración SQL, pero solo la hemos consultado una vez, entonces, ¿por qué enviamos tantas declaraciones? Este es el problema común 1+n. El llamado problema 1+n es primero emitir una declaración para consultar el objeto actual, y luego emitir n declaraciones para consultar el objeto asociado, por lo que la eficiencia se vuelve muy baja. Solo hay dos objetos aquí. Si hay más objetos, la eficiencia se reducirá considerablemente. ¿Cómo debemos resolver este problema?
Tal vez piense que si configura Fetch para generar fetchtype.lazy, no publicará múltiples declaraciones, pero esto definitivamente no es posible, porque después de configurarlo en perezoso, no podemos obtener el objeto de la cuenta. La mejor solución es escribir la declaración de HQL nosotros mismos y usar Join Fetch. Para obtener más detalles, mire la clase de implementación de CategyServiceImpl modificada:
@Service ("CategoryService") Clasifica de clase pública CategyServiceImpl extiende BaseServiceImpl <Category> Implementa CategyService {@Override Public List <Cateatory> QueryjoinAccount (Tipo de cadena) {String HQL = "de la categoría C Left C.Account Where C.TypE como: Type"; return getSession (). CreateQuery (HQL) .SetString ("Tipo", "%" + Tipo + "%"). List (); }} Left une para consultar junto con la cuenta, Fetch significa agregar el objeto de cuenta a la categoría, de modo que solo se enviará una declaración SQL, y la categoría devuelta también contiene el objeto de cuenta.
3. Completa la función de paginación
La paginación en Hibernate es muy simple. Solo necesita llamar a dos métodos setFirStresult y setMaxResults: modificemos la interfaz CategoryService y su clase de implementación CategyServiceImpl:
// CategyService Interfaz pública La categoría CategyService extiende BasesService <Cateatory> {// Información de categoría de consulta, en cascada la lista pública del administrador <Cateatory> QueryjoinAccount (Tipo de cadena, página int, tamaño int); // e implementar paginación} // categoryServiceImpl @Service ("CategyService") Clasificación pública CategyServiceImpl extiende BaseServiceImpl <Catexatory> implementa CategoryService {@Override public Lists <CatyJeatory> QueryjoinAcCount (tipo de cadena, intel, int tize) {String Hql = "de la categoría de Categoría C de la izquierda. return getSession (). CreateQuery (HQL) .SetString ("Tipo", "%" + Tipo + "%") .SetFirStresult ((Page-1) * Size) // show .SetMaxResults (size) // show varias .list (); }} Vamos a probarlo en la clase de prueba:
@RunWith (SpringJunit4ClassRunner.class) @ContextConfiguration (ubicaciones = "classpath: beans.xml") Categoría de clase públicaServiceImplTest {@Resource Categoría privada Categoría de servicio; @Test public void testQueryjoinAccount () {for (categoría C: categoryService.QueryjoinAccount ("", 1,2)) {// Muestra la primera página, 2 piezas de datos por página System.out.println (c + "," + c.getaccount ()); }}} Con este fin, hemos terminado de escribir el método de servicio y completamos las funciones de consulta y paginación en cascada de las categorías de productos.
(Nota: ¡Al final, proporcionaré la descarga del código fuente de todo el proyecto! Todos son bienvenidos a recopilar o compartir)
Dirección original: http://blog.csdn.net/eson_15/article/details/51320212
Lo anterior es todo el contenido de este artículo. Espero que sea útil para el aprendizaje de todos y espero que todos apoyen más a Wulin.com.