Multiple Schema Configuration On Spring MVC + Hibernate + JPA

The new schema is in the same database/url but with different username and password. I

With Oracle, Schema and User are tightly related.

I propose a no JTA solution because your configuration doesn't rely on Java EE datasource.
To address this change you should consider having two sets of datasources/entityManagerfactory/transactionmanager : one for read-only user/schema and another for read-write user/schema. Of course, the common configuration could be factored in properties.

To give you an idea, I modified your xml conf and I started the job (I didn't factor properties duplication but you should) :

xmlns:context="http://www.springframework.org/schema/context"
xmlns:tx="http://www.springframework.org/schema/tx"
xmlns:jdbc="http://www.springframework.org/schema/jdbc"
xmlns:jpa="http://www.springframework.org/schema/data/jpa"
xsi:schemaLocation="
    http://www.springframework.org/schema/beans 
    http://www.springframework.org/schema/beans/spring-beans.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/jdbc
    http://www.springframework.org/schema/jdbc/spring-jdbc.xsd
    http://www.springframework.org/schema/data/jpa
    http://www.springframework.org/schema/data/jpa/spring-jpa.xsd">

<jpa:repositories base-package="org.portal.data.repository" />

<!-- The original declaration is no longer valid --!>
<tx:annotation-driven  transaction-manager="transactionManagerRead" />

<bean id="transactionManagerRead"
    class="org.springframework.orm.jpa.JpaTransactionManager">
    <property name="entityManagerFactory" ref="entityManagerFactoryRead"/>
</bean>

<bean id="transactionManagerReadWrite"
    class="org.springframework.orm.jpa.JpaTransactionManager">
    <property name="entityManagerFactory" ref="entityManagerFactoryReadWrite"/>
</bean>

<bean id="entityManagerFactoryRead"
    class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
    <property name="dataSource" ref="dataSourceRead" />
    <property name="jpaVendorAdapter">
        <bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter">
            <property name="database" value="${database.database}"/>
            <property name="databasePlatform" value="${database.databasePlatform}"/>
            <property name="showSql" value="${database.showSql}"/>
            <property name="generateDdl" value="${database.generateDdl}"/>
        </bean>
    </property>
    <property name="packagesToScan" value="org.portal.entity"/>
</bean>
<bean id="entityManagerFactoryReadWrite"
    class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
    <property name="dataSource" ref="dataSourceReadWrite" />
    <property name="jpaVendorAdapter">
        <bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter">
            <property name="database" value="${database.database}"/>
            <property name="databasePlatform" value="${database.databasePlatform}"/>
            <property name="showSql" value="${database.showSql}"/>
            <property name="generateDdl" value="${database.generateDdl}"/>
        </bean>
    </property>
    <property name="packagesToScan" value="org.portal.entity"/>
</bean>    

And so for...

There is however a tricky matter in the spring configuration :

<tx:annotation-driven/>

It uses by default a transaction manager bean named transactionManager. So you should configure it with one of transaction managers as I did :

<tx:annotation-driven  transaction-manager="transactionManagerRead" />

Then, to apply the suitable transaction manager in your processing, you should specify in your Spring services the transactionManager to use (read or read-write). You can also define a primary transactionManager which will be used by default. By security, it should be the transactionManager with the most of limitation.

For example, in a Spring Service Bean where you do only reading, you could declare the class to use read-only transaction manager :

@Transactional(transactionManager="TransactionManagerRead")
public class CustomerSearchService(){
...

Of course, you can define the transaction manager at method level.
But ideally, if you have almost as many methods in writing and in reading, you should check if you can redesign or rearrange your classes to gather read-only and write methods. It would be more maintainable and less error-prone.