Jahia in English > When I deploy a...

0 (0 Good)
0 (0 Bad)

When I deploy a module to Jahia, I got an error message " zip file closed"

by  omglion »  2014/07/22 03:37

Hello, everybody,

Could anyone help me to solve the problem?

Here is the source codes (that is for reading datas from an external datasource like mysql):

package com.caii.modules.caiidbprovider;

import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;

import javax.annotation.Resource;
import javax.jcr.ItemNotFoundException;
import javax.jcr.PathNotFoundException;
import javax.jcr.RepositoryException;

import net.sf.ehcache.CacheException;
import net.sf.ehcache.Ehcache;
import net.sf.ehcache.Element;

import org.apache.commons.lang.StringUtils;
import org.jahia.modules.external.ExternalData;
import org.jahia.modules.external.ExternalDataSource;
import org.jahia.services.cache.ehcache.EhCacheProvider;

import com.caii.modules.caiidbprovider.dao.PersonDao;
import com.caii.modules.caiidbprovider.domain.Person;
import com.google.common.collect.Sets;

public class CaiiDataSource implements ExternalDataSource {
    
    private EhCacheProvider ehCacheProvider;
    private Ehcache cache;
    
    @Resource
    private PersonDao personDao;
    
    public CaiiDataSource() {
        super();
    }
    
    public void setCacheProvider(EhCacheProvider ehCacheProvider) {
        this.ehCacheProvider = ehCacheProvider;
    }
    
    public void start(){
        try {
            if(!ehCacheProvider.getCacheManager().cacheExists("caiidb-cache")){
                ehCacheProvider.getCacheManager().addCache("caiidb-cache");
            }
            cache = ehCacheProvider.getCacheManager().getCache("caiidb-cache");
            
        } catch (IllegalStateException e) {
            e.printStackTrace();
        } catch (CacheException e) {
            e.printStackTrace();  
        }
    }

    @Override
    public List<String> getChildren(String path) throws RepositoryException {
        return null;
    }

    @Override
    public ExternalData getItemByIdentifier(String identifier) throws ItemNotFoundException {
        try {
            if(identifier.equals("root")){
                return new ExternalData(identifier, "/", "jnt:contentFolder", new HashMap<String, String[]>());
            }
            
            if(identifier.equals("persons-folder")){
                final String s = StringUtils.substringBefore(identifier, "-folder");
                
                return new ExternalData(identifier, "/" + s, "jnt:contentFolder", new HashMap<String, String[]>());
            } else if (identifier.startsWith("personId-")) {
                String personId = StringUtils.substringAfter(identifier, "personId-");
                
                try {
                    Integer.parseInt(personId);
                } catch (NumberFormatException e) {
                    throw new ItemNotFoundException(identifier);
                }
                
                Person person = null;
                
                if (cache.get("personId-" + personId) != null) {
                    person = (Person) cache.get("personId-" + personId).getObjectValue();
                } else {
                    person = personDao.findPersonById(personId);
                    cache.put(new Element("personId-" + personId, person));
                }
                
                Map<String, String[]> properties = new HashMap<String, String[]>();
                
                if(person.getPersonId() != null){
                    properties.put("person_id", new String[]{person.getPersonId() + ""});
                }
                
                if(!StringUtils.isBlank(person.getName())){
                    properties.put("name", new String[]{person.getName()});
                }
                
                ExternalData externalData = new ExternalData(
                        identifier, "/persons/" + personId, "caiint:person", properties);
                
                return externalData;                
                
            }
            
        } catch (Exception e) {
            throw new ItemNotFoundException(e);
        }
        
        throw new ItemNotFoundException(identifier);
    }

    /**
     * the path of external data node is:
     *"/persons/123"
     *123 is id
     * */
    @Override
    public ExternalData getItemByPath(String path) throws PathNotFoundException {
        
        String[] splitPath = path.split("/");
        
        try {
            if (path.endsWith("j:acl")) {
                throw new PathNotFoundException(path);                
            }
            
            if (splitPath.length <= 1) {
                return getItemByIdentifier("root");
            } else if (splitPath[1].equals("persons")) {
                switch(splitPath.length){
                case 2:
                    return getItemByIdentifier("persons-folder");
                case 3:
                    return getItemByIdentifier("personId-" + splitPath[2]);                
                }                
            } 
            
        } catch (ItemNotFoundException e) {
            throw new PathNotFoundException(e);
        }
        
        throw new PathNotFoundException();
    }

    @Override
    public Set<String> getSupportedNodeTypes() {
        return Sets.newHashSet("jnt:contentFolder", "caiint:person");
    }

    @Override
    public boolean isSupportsHierarchicalIdentifiers() {
        return false;
    }

    @Override
    public boolean isSupportsUuid() {
        return false;
    }

    @Override
    public boolean itemExists(String path) {
        return false;
    }

}

And the Spring xml file:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:osgi="http://www.eclipse.org/gemini/blueprint/schema/blueprint"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:context="http://www.springframework.org/schema/context" 
       xmlns:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
                        http://www.eclipse.org/gemini/blueprint/schema/blueprint http://www.eclipse.org/gemini/blueprint/schema/blueprint/gemini-blueprint.xsd
                        http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd
                        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
                        http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd
                        http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd">  
    
    <!-- 将OSGI服务转换成bean,以便调用 -->
    <osgi:reference id="ExternalProviderInitializerService" interface="org.jahia.modules.external.ExternalProviderInitializerService"/>
    <osgi:reference id="ehCacheProvider" interface="org.jahia.services.cache.ehcache.EhCacheProvider"/>
    
    <!-- 启动扫描 -->
    <context:component-scan base-package="com.caii.modules"/>
    
    <!--默认使用JDK动态代理,如果没有实现接口,自动用CGLIB动态代理-->
    <aop:aspectj-autoproxy/>
    
    <!-- DataSource 用于管理数据库的连接 -->
    <bean id="dataSource" class="org.apache.commons.dbcp2.BasicDataSource" destroy-method="close">
        <property name="driverClassName" value="com.mysql.jdbc.Driver" />
        <property name="url" value="jdbc:mysql://localhost/test?useUnicode=true&amp;characterEncoding=UTF-8" />
        <property name="username" value="root" />
        <property name="password" value="1234" />
    </bean>
    
    <!-- 事务管理器 -->
    <bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
        <property name="entityManagerFactory" ref="entityManagerFactory"/>
    </bean>
    <!-- 声明注解事务 -->
    <tx:annotation-driven transaction-manager="transactionManager"/>

    <bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
        <property name="persistenceUnitName" value="caiiPU" />
        <property name="dataSource" ref="dataSource" />
    </bean>
    
    <!--Provider Definition 用于映射数据到JCR-->
    <bean id="caiiDBProvider" class="org.jahia.modules.external.ExternalContentStoreProvider" parent="AbstractJCRStoreProvider" >
        <property name="key" value="caiiDBProvider"/>
        <property name="mountPoint" value="/sites/caiisite/contents/caii-db-provider"/>
        <property name="externalProviderInitializerService" ref="ExternalProviderInitializerService"/>
        <property name="extendableTypes">
            <list>
                <value>nt:base</value>
            </list>
        </property>
        <property name="dataSource" ref="caiiDataSource"/>
    </bean>
    
    <!-- caii数据源,从DAO中读取数据,封装成ExternalData,再由Provider映射数据到JCR -->
    <bean name="caiiDataSource" class="com.caii.modules.caiidbprovider.CaiiDataSource" init-method="start">
        <property name="cacheProvider" ref="ehCacheProvider"/>
    </bean>
    
    
</beans>

 

Kindly regards

Lion

  (omglion)

Number of messages  27
Registration date
Contact
Share
Feedback

Get in touch

Whether you are a current user or if you are just evaluating Jahia, we are here to help.

Contact us

Share this page