I Tyskland har Israelfrågan en särskild klang

<div class="kv-article-audio-player">  <div class="kv-aap-listen">    <div class="kv-listen-left">      <span>        <i class="fas fa-headphones-alt"></i>      </span>    </div>    <div class="kv-aap-listen-right">      Lyssna på texten    </div>  </div><div id    = "kv-pod-holder-113325"      class = "kv-pod-holder kv-player-light  lplo " data-sid="" data-eid="" data-pid="113325" data-acurl="aHR0cHM6Ly9tZWRpYS5wb2Quc3BhY2Uva3ZhcnRhbC82LTU2LWktdHlza2xhbmQtaGFyLWlzcmFlbGZyYWdhbl9lbi1zYXJza2lsZC1rbGFuZy5tcDM=" data-psurl="aHR0cHM6Ly9tZWRpYS5wb2Quc3BhY2Uva2p4ajYzeWRkZXEydmgvNi01Ni1pLXR5c2tsYW5kLWhhci1pc3JhZWxmcmFnYW5fZW4tc2Fyc2tpbGQta2xhbmcubXAz">  <div class="kv-pod-holder-inner">    Laddar <span class="blink-me">...</span>  </div></div>  <div class="kv-listen-subscribe">    <span>Följ Kvartals poddar:</span>    <a target="_blank" href="https://podcasts.apple.com/se/podcast/kvartal/id1447122576?mt=2">Apple</a>    |     <a target="_blank" href="https://open.spotify.com/show/6NsieE1iFLypikr3slKII0?si=ppaUJpA3R-mo8L9L4XgudA">Spotify</a>  </div></div><div class="kvartal-meta clearfix" style="color: ">Av <a href="https://kvartal.se/medverkande/andreas-akerlund/">Andreas&nbsp;Åkerlund</a> | 7 november 2023<div style="float: right;" class="social-top-wrapper closed no-comments"><div class="share-icons"><span class="share-outer"><a href="https://www.facebook.com/sharer.php?u=https%3A%2F%2Fkvartal.se%2Fartiklar%2Fi-tyskland-har-israelfragan-en-sarskild-klang%2F&amp;t=I+Tyskland+har+Israelfr%C3%A5gan+en+s%C3%A4rskild+klang"    target="_blank"    class="fb-link"    title="Dela på facebook"><i class="fa fa-facebook ui transparent"></i></a><a href   = "https://twitter.com/intent/tweet?text=I+Tyskland+har+Israelfr%C3%A5gan+en+s%C3%A4rskild+klang+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Fi-tyskland-har-israelfragan-en-sarskild-klang%2F"    target = "_blank"    class  = "tw-link"    title  = "Dela på X.com"><i class="exticon exticon-x-icon"></i></a></span><span class="share-inner"><a href   = "http://www.linkedin.com/shareArticle?mini=true&url=https%3A%2F%2Fkvartal.se%2Fartiklar%2Fi-tyskland-har-israelfragan-en-sarskild-klang%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=I Tyskland har Israelfrågan en särskild klang&body=https://kvartal.se/artiklar/i-tyskland-har-israelfragan-en-sarskild-klang/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/113325/utskrift"    target  = "_blank"    class   = "pr-link"    title   = "Skriv ut"    onclick = ""><i class="ti-printer ui transparent"></i></a><a href   = "https://kvartal.se/skriv-ut/113325/pdf"    target = "_blank"    class  = "pr-link"    title  = "Ladda ner artikeln som PDF"><i class="fas fa-file-pdf ui transparent"></i></a></span><a href="#share" class="share-expand "    title="Visa fler delningsalternativ"><i class="fas fa-share-square ui transparent"></i></a></div></div></div><div class="kv-art-ext-sep"></div><div class="mobile-share clearfix" style="margin-top: -10px; margin-bottom: 20px;"><div class="share-icons"><span class="share-outer"><a href="https://www.facebook.com/sharer.php?u=https%3A%2F%2Fkvartal.se%2Fartiklar%2Fi-tyskland-har-israelfragan-en-sarskild-klang%2F&amp;t=I+Tyskland+har+Israelfr%C3%A5gan+en+s%C3%A4rskild+klang"    target="_blank"    class="fb-link"    title="Dela på facebook"><i class="fa fa-facebook ui transparent"></i></a><a href   = "https://twitter.com/intent/tweet?text=I+Tyskland+har+Israelfr%C3%A5gan+en+s%C3%A4rskild+klang+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Fi-tyskland-har-israelfragan-en-sarskild-klang%2F"    target = "_blank"    class  = "tw-link"    title  = "Dela på X.com"><i class="exticon exticon-x-icon"></i></a></span><span class="share-inner"><a href   = "http://www.linkedin.com/shareArticle?mini=true&url=https%3A%2F%2Fkvartal.se%2Fartiklar%2Fi-tyskland-har-israelfragan-en-sarskild-klang%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=I Tyskland har Israelfrågan en särskild klang&body=https://kvartal.se/artiklar/i-tyskland-har-israelfragan-en-sarskild-klang/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/113325/utskrift"    target  = "_blank"    class   = "pr-link"    title   = "Skriv ut"    onclick = ""><i class="ti-printer ui transparent"></i></a><a href   = "https://kvartal.se/skriv-ut/113325/pdf"    target = "_blank"    class  = "pr-link"    title  = "Ladda ner artikeln som PDF"><i class="fas fa-file-pdf ui transparent"></i></a></span><a href="#share" class="share-expand "    title="Visa fler delningsalternativ"><i class="fas fa-share-square ui transparent"></i></a></div></div><div class="article-actions"><a href="/profile" class="kv-aa-profile"><svg aria-hidden="true">  <use href="#tf-ti-user"></use></svg><span>Profil</span></a><a class="listen" href="https://kvartal.se/artiklar/i-tyskland-har-israelfragan-en-sarskild-klang/?inlast=1">  <i class="fas fa-headphones-alt"></i>  <span>Inlästa texter</span></a><a href="#nyhetsbrevet" onclick="newsletter()" class="newsletter"><i class="fas fa-paper-plane"></i><span>Nyhetsbrev</span></a><a class="reading-time" title="Ungefärlig lästid"><i class="far fa-clock ui"></i><span>Lästid 6 min</span></a><a href   = "https://kvartal.se/skarmlasarvanlig/113325"    target = "_blank"    class  = "screen-reader-friendly"    title. = "Version som fungerar bättre med skärmläsarprogramvara">  <i class="fas fa-volume-up"></i>  <span>Skärmläsarvänlig</span></a></div><div class="in-short-wrapper closed" id="in-short-113325">  <div class="in-short-inner">    <span class="close_button close-in-short in-short-toggle" data-articleid = "113325"></span>    <i class="themify-icon-icon fas fa-align-left"></i>    <span class="in-short-heading">I korthet</span>    <hr class="in-short-divider" />    <div class="in-short-text">    </div>  </div></div><div class="article-beginning ">Den uppblossande konflikten i Mellanöstern har visat hur instabil den tyska regeringskoalitionen mellan socialdemokraterna i <em>SPD</em>, miljöpartiet <em>Die Grünen</em> och det liberala partiet <em>FDP</em> är.</p>
</div>
<div class="rest-of-article ">
<p>Även om regeringen är stark i förbundsdagen, har särskilt <em>SPD</em> tappat väljarstöd i de senaste två delstatsvalen. I Hessen blev man tredje största parti efter <em>CDU</em> och <em>AfD</em> och i Bayern är <em>SPD</em> lantdagens minsta parti efter <em>CDU:s</em> systerparti <em>CSU</em>, <em>Freie Wähler</em>, <em>Die Grünen</em> och <em>AfD</em>. Nyare opinionsmätningar visar att regeringspartierna samlar ungefär 35 procent av väljarna, medan de båda största oppositionspartierna <em>CDU</em> och <em>AfD</em> hamnar på 30 procent respektive 21 procent.</p>
<h2>Invandringen präglar politiken</h2>
<p>Det tema som dominerat den tyska politiska diskussionen under sommaren och hösten är asyl- och integrationspolitiken. Antalet asylansökningar 2023 ligger hittills på en nivå som landet inte sett sedan 2016. I slutet av augusti hade 205 000 personer sökt asyl i Tyskland, vilket var en ökning med 77 procent jämfört med 2022 och preliminära siffror för oktober indikerar en snabbare ökning.<sup>1</sup></p>
<p>Antalet personer i landet som har ett avvisningsbeslut som inte kan verkställas är också högt. Det finns 14 000 personer bara från Nigeria som måste lämna landet, men där avvisningen inte kan verkställas eftersom hemlandet inte vill ta emot dem. När förbundskansler <strong>Olaf Scholz</strong> besökte Nigeria i slutet av oktober var därför, vid sidan av bilaterala handelsförbindelser, migration ett centralt tema.</p>
<p>Även vid inrikesminister <strong>Nancy Faesers</strong> besök i Marocko stod migrationspolitik, eller snarare remigrationspolitik, högt på dagordningen. Asyl och migration är också ett tema som splittrar regeringen, där särskilt SPD vill gå i en mer restriktiv riktning med sänkta ersättningar för asylsökande och ett starkare fokus på att utvisa personer utan uppehållstillstånd – ambitioner som inte delas av de gröna regeringskollegerna.</p>
<p>Tyskland har dock som ett resultat av de många asylansökningarna infört gränskontroller mot Polen, Tjeckien och Schweiz.</p>
<p>Till denna redan intensiva inrikespolitiska diskussion kom sedan Hamas överfall och massaker på israeliska civila den 7 oktober och det israeliska svaret i form av militära angrepp på mål i Gaza. Att hävda att Tyskland har en speciell relation till Israel är ingen överdrift. När <strong>Angela Merkel</strong> besökte Israel 2008 sa hon i sitt tal i Knesset att Tyskland på grund av Förintelsen har ett särskilt ansvar för Israels säkerhet.<sup>2</sup> Bland dem som Hamas dödade och kidnappade fanns också flera tyska medborgare, där den som fått mest uppmärksamhet var 22-åriga <strong>Shani Louk</strong> som nu konstaterats död.</p>
<h2>Kraftiga reaktioner bland muslimer</h2>
<p>Stödet för Israel var inledningsvis starkt i befolkningen som helhet. Det finns dock nyare opinionsundersökningar som antyder att allt större delar av befolkningen börjar se Israels agerande i Gaza som oproportionerligt.<sup>3</sup> De demonstrationer som genomförts till stöd för Israel kan dock inte mäta sig med de demonstrationer som ägt rum till stöd för Palestina.</p>
<p>För i Tyskland bor, främst i Berlin, ungefär 45 000 personer med palestinska rötter, vars historia i landet går tillbaka till inbördeskriget i Libanon i slutet av 1900-talet.<sup>4</sup> Antalet muslimer i Tyskland är ungefär 5,5 miljoner och precis som i Sverige finns radikaliserade islamistiska miljöer, vilket är en fråga som debatterats länge i Tyskland. Framväxten av parallellsamhällen, hur man ska skapa värderingsgemenskaper och frågan om en tysk ”<a href="https://en.wikipedia.org/wiki/Leitkultur">Leitkultur</a>” har varit en del av den stora debatten om migration och integration.</p>
<blockquote><p>De radikala islamisterna utmanar oss om makten på våra gator.</p></blockquote>
<p>Israels angrepp på Hamas i Gaza resulterade i kraftiga reaktioner från främst muslimska grupper, stödda av den ytterkantsvänster som i Tyskland betecknar sig själv som autonom och antikolonial. De demonstrationer som hållits till stöd för Gaza och mot Israel har varit välbesökta. Demonstrationerna har också använts för att sprida ett radikalt islamistiskt budskap. Så exempelvis i Essen, där demonstranterna <a href="https://www.zeit.de/gesellschaft/zeitgeschehen/2023-11/nahostkonflikt-demonstration-essen-islamismus-palaestina-israel">enligt flera tidningar</a> hade islamistiska fanor och i talkörer krävde inrättandet av ett kalifat.</p>
<p>I flera tyska städer har oanmälda pro-palestinska demonstrationer urartat i kravaller, till exempel i Berlin den 18 oktober och i Hamburg den 20 samma månad. I Hamburg kastades flaskor och stenar mot polisen och efter kravallerna i Berlin rapporterades om 65 skadade poliser.<sup>5</sup></p>
<p>I en intervju betonade <strong>Rainer Wendt</strong> från polisfacket DPolG (<em>Deutsche Polizeigewerkschaft</em>) att den tyska polisen stod under hård press, och menade att man var på gränsen till att inte kunna upprätthålla lag och ordning och talade om en risk för den starkes rätt på Tysklands gator. ”De radikala islamisterna utmanar oss om makten på våra gator”, menade han. ”Den utmaningen måste avgöras till vår fördel, annars härskar inte längre grundlagen, utan sharia.”<sup>6</sup></p>
<p>Samtidigt rapporterar RIAS, en organisation för forskning och information om antisemitism, om en kraftig ökning av antisemitiska händelser i Tyskland som en reaktion på Israels angrepp på Hamas i Gaza. För perioden 7–15 oktober registrerade RIAS en ökning med 240 procent i relation till samma vecka året innan.<sup>7</sup></p>
<h2>En fråga med särskild resonansbotten i Tyskland</h2>
<p>Det är inte förvånande att debatten om migration, asyl och integration har fått en helt ny dimension i och med att Tyskland nu upplever en våg av antisemitiska övergrepp i samband med en konflikt i Mellanöstern.</p>
<p>Att det klottras davidsstjärnor på bostadshus där judar tros bo eller att det kastas molotovcocktails mot en synagoga är händelser som just i Tyskland sker mot en ytterst sinister historisk fond. Kvällstidningen <em>Bild</em> höjde temperaturen i den politiska debatten ytterligare genom att publicera ett <a href="https://www.bild.de/politik/inland/politik-inland/bild-manifesto-germany-we-have-a-problem-85895486.bild.html">manifest i 50 punkter</a>, på både tyska och engelska, där man beskrev situationen som en helt ny dimension av hat mot västerländska värderingar, mot demokratin och mot Tyskland som land.<sup>8</sup></p>
<blockquote><p>Scholz regering har ett svagt stöd i befolkningen.</p></blockquote>
<p>Den tyska regeringen har funnit tydliga ord för att fördöma såväl Hamas överfall i Israel som kravaller och antisemitiska övergrepp i Tyskland. Nu senast var det <strong>Robert Habeck</strong> från <em>Die Grünen</em> som i en <a href="https://www.youtube.com/watch?v=MdZvkkpJaVI">video</a> uttalade sig tydligt mot antisemitismen. Frågan är dock vad man tänker göra. Tyskland lade exempelvis ned sin röst i FN vid omröstningen om den resolution som fördömde våldet mot civila i Israel och Gaza, dock utan att nämna Hamas. En nedlagd röst i FN är verkligen inte att ta ett särskilt ansvar för Israels säkerhet, menade kritikerna. Samma sak gäller det nya förbudet mot Hamas och nätverket <em>Samidoun</em> (”för solidaritet med palestinska fångar”) som inrikesminister Nancy Faeser tillkännagav häromdagen, där kritiken har handlat om senfärdighet.<sup>9</sup> Det är många som frågar sig varför det måste till en massaker i Israel innan man kan förbjuda en organisation som Hamas.</p>
<p>Det är långt till 2025 och nästa val till Bundestag, men Scholz regering har ett svagt stöd i befolkningen och den har hittills präglats av intern splittring. Förra året präglades av frågan om hållningen till Ryssland och vapenleveranser till Ukraina. Nu handlar det om migrationen och hur man tänker hantera den allt starkare antisemitismen. Ledande personer inom FDP har redan börjat tänka högt om att lämna regeringen, och representanter för CDU har antytt att de är öppna för en stor koalition om Scholz tycker att de gröna börjar bli omöjliga som koalitionspartner.</p>
<p>Oavsett regeringssammansättning kommer dock situationen i Tyskland med största sannolikhet att fortsätta vara besvärlig under överskådlig tid. Antisemitismen som nu kommer upp till ytan lär inte försvinna av sig själv. Tvärtom utmanar den en central aspekt i den tyska självförståelsen, nämligen att ha lärt av Förintelsen.</p>
<p>Högtidstalens löfte om att antisemitismen &#8221;aldrig mer&#8221; ska få fäste i Tyskland är för tillfället långt från att uppfyllas.  <a href="#_ftnref1" name="_ftn1"></a></p>
<div class="notes-wrapper"><a class="shadow-button noselect show-notes"  data-articleid="113325">  <span class="button-inner-wrapper">    <span class="left-part">      <i class="ti-arrow-circle-down"></i>    </span>    <span class="right-part">      <span class="default-text">Se noter</span>      <span class="open-text">Visa mindre</span>    </span>  </span></a></p>
<div class="references">
<h3 id="noter" class="ref-heading" style="color: #000;;">Noter</h3>
<ol>
<li><a href="https://www.welt.de/politik/deutschland/plus247335860/Migration-77-Prozent-Asylantraege-mehr-als-2022-Anstieg-beschleunigt-sich.html">https://www.welt.de/politik/deutschland/plus247335860/Migration-77-Prozent-Asylantraege-mehr-als-2022-Anstieg-beschleunigt-sich.html</a>; <a href="https://www.welt.de/politik/deutschland/article242009189/BAMF-Zahl-der-Asylantraege-steigt-im-Oktober-sehr-stark-an.html">https://www.welt.de/politik/deutschland/article242009189/BAMF-Zahl-der-Asylantraege-steigt-im-Oktober-sehr-stark-an.html</a></li>
<li>https://www.bundesregierung.de/breg-de/service/bulletin/rede-von-bundeskanzlerin-dr-angela-merkel-796170</li>
<li>https://www.welt.de/politik/deutschland/article248326210/Umfrage-41-Prozent-der-Deutschen-geht-Israels-Kampf-gegen-den-Hamas-Terror-zu-weit.html</li>
<li>https://taz.de/Debatte-um-Berliner-Sonnenallee/!5965454/</li>
<li>https://www.tagesspiegel.de/berlin/174-festnahmen-und-stundenlange-ausschreitungen-bei-berliner-palastina-demo-10649041.html; https://www.zeit.de/politik/deutschland/2023-10/demonstration-pro-palaestina-hamburg-ausschreitungen-polizei</li>
<li>https://www.stern.de/news/polizeigewerkschaft-warnt-vor&#8211;recht-des-staerkeren&#8211;auf-deutschlands-strassen-33954534.html</li>
<li><a href="https://www.report-antisemitism.de/documents/2023-10-18_antisemitische_reaktionen_in_deutschland_auf_die_hamas-massaker_in_israel.pdf">https://www.report-antisemitism.de/documents/2023-10-18_antisemitische_reaktionen_in_deutschland_auf_die_hamas-massaker_in_israel.pdf</a>. Se även <a href="https://www.ndr.de/nachrichten/info/Seit-Hamas-Angriff-Deutlich-mehr-antisemitische-Vorfaelle,antisemitismus334.html">https://www.ndr.de/nachrichten/info/Seit-Hamas-Angriff-Deutlich-mehr-antisemitische-Vorfaelle,antisemitismus334.html</a></li>
<li>https://www.bild.de/politik/inland/politik-inland/bild-manifesto-germany-we-have-a-problem-85895486.bild.html</li>
<li>https://tagesschau.de/inland/innenpolitik/verbot-hamas-samidoun-100.html</li>
</ol>
</div>
</div>
<div class="author-byline">Andreas Åkerlund är professor i historia vid Södertörns högskola, och specialiserad på offentlig diplomati och modern tysk historia.
</div>
</div>
