Comment faire pour exécuter un shell de JSP?

Ma question est auto-explicatif. Je veux exécuter un shell, c'est l'appel d'une procédure, d'une JSP à l'aide d'un bouton.

La procédure est

CREATE OR REPLACE PROCEDURE DEMO_PRC (dist IN variable,mrno IN variable,
yr IN variable,flags OUT number)
IS
begin
flags:=0;
// CODE THAT GENERATES A UTIL.....
flags:=1;
end;
/

Et la coquille est:

sqlplus demo_user/123456@demo
var a NUMBER(4);
exec DEMO_PRC($1,$2,,$3,:a);
print a;

Nommé dist.sh et il est exécuté en ligne de commande comme:

dist.sh 3 1937 10

Mais je veux l'exécuter à partir d'une JSP lorsque je clique sur un bouton. Mais je ne connais pas la syntaxe pour exécuter le shell(.sh) de JSP.

OriginalL'auteur anand | 2010-03-09

7

Vous pouvez exécuter des commandes arbitraires processus via le Exécution de la classe:
```
Runtime.getRuntime().exec("...a string here specifying the command to run...");
```
Il y a plusieurs surcharges selon le niveau de contrôle dont vous avez besoin, etc. Vous aurez besoin pour être sûr que le compte d'utilisateur de votre Jsp utilisation a accès à tout ce qui est nécessaire pour la commande que vous êtes en cours d'exécution.

OriginalL'auteur T.J. Crowder
2

Résolu le problème.M'a fallu du temps, de 6 heures. pour être exact, mais il a obtenu le
résultat souhaité.

Voici comment:
1. Pour appeler la procédure qui génère l'util, j'ai d'abord appel à une jsp(à l'aide de
  de la fenêtre.ouvrez les paramètres de la cible lower_frame). Il y a usage Appelable
  Déclaration et appel de la proc. avec les paramètres envoyés. La syntaxe est la suivante:
```
Callable Statement cs = null;
cs = mk.con.prepareCall( "{call DPD_PRINT_LETTER(?,?,?,?)}" );
cs.setString......//4 params.
cs.execute();
```
  Puis à l'aide BufferedReader, j'appelle l'util et de produire sur la
  lower_frame. Syntaxe:
```
 %
BufferedReader bfreader = new BufferedReader(new
FileReader("/ltora/oracle64/j2ee/LtTest/LtTest/reports/MNOS_LETT_"+mrno+"."+IPaddr));
String data = new String("");
while((data = (String)bfreader.readLine())!=null
{
           String temp=data.replaceAll(" ","&nbsp");
% 
tr 
     td style="font-family: Courier New; font-size: 12pt; font-weight:
bold" 
          %= temp % 
     /td 
     /tr 
 % } % 
```
2. Maintenant d'appeler le shell qui va imprimer le rapport, je l'appelle un
  java(again.with params) à l'aide de ActiveXObject(say x) et la fonction:
```
x.open('GET',url,true);
```
  Ici l'URL contient le java. En java, j'ai fait:
```
Process child = null;
Runtime anyRuntime = Runtime.getRuntime();
child = anyRuntime.exec(strShellLine);
```
  Ici "strShellLine" contient le shell URL......et c'est tout là est à lui.
OriginalL'auteur anand
1

Il y a un malentendu ici. JSP est une technologie d'affichage qui fournit un modèle à écrire en HTML/CSS/JS et offre la possibilité d'interagir avec le backend de code Java dans la saveur de taglibs et EL lors de la génération de la réponse. Il peut toutefois être fait avec la normale de code Java. Vous pourrait écrire que dans un fichier JSP, mais il est considéré comme une mauvaise pratique. Code Java appartient au réel des classes Java. Votre problème est en fait de diviser en 2 parties.

D'abord la question de la façon d'exécuter la tâche désirée à l'aide du code Java. Comme répondu à plusieurs reprises avant d'en avoir besoin Runtime#exec() pour cela. Cependant, assurez-vous que vous avez lu et compris toutes les 4 pages de cet article! Voici un coup d'envoi exemple:
```
public class YourShellClass {
    public Result execute() {
        Runtime runtime = Runtime.getRuntime();
        // ... implement
        return result;
    }
}
```
Maintenant à gauche derrière la question de savoir comment l'invoquer à l'aide d'un formulaire HTML qui est servi par une page JSP. Supposons que le formulaire HTML ressembler à ceci:
```
<form action="run" method="post">
    <input type="submit" value="run">
</form>
```
Ce formulaire enverra une requête POST à http://example.com/somecontext/run. Pour exectue code Java à chaque fois que cette demande arrive à votre serveur, il suffit de créer une classe qui extends HttpServlet qui écoute sur un url-pattern de /run et a la doPost() à peu près mis en œuvre comme suit:
```
protected void doPost(HttpServletRequest request, HttpServletResposne response) throws ServletException, IOException {
    YourShellClass yourShellClass = new YourShellClass();
    Result result = yourShellClass.execute();
    // ... do something with it?

    // Then display some result page?
    request.getRequestDispatcher("result.jsp").forward(request, response);
}
```
en outre, au lieu d'utiliser un script shell, je pense qu'il peut faire les opérations SQL qu'il veut directement à partir de Java.
Pas tous les pilotes JDBC supporte tous les types d'instructions DDL.

OriginalL'auteur BalusC

Vous devez vous connecter pour publier un commentaire.